LAPACK
3.4.2
LAPACK: Linear Algebra PACKage

Functions/Subroutines  
program  dchkaa 
DCHKAA  
program  dchkab 
DCHKAB  
subroutine  dchkeq (THRESH, NOUT) 
DCHKEQ  
subroutine  dchkgb (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, A, LA, AFAC, LAFAC, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DCHKGB  
subroutine  dchkge (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DCHKGE  
subroutine  dchkgt (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DCHKGT  
subroutine  dchklq (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT) 
DCHKLQ  
subroutine  dchkpb (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DCHKPB  
subroutine  dchkpo (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DCHKPO  
subroutine  dchkpp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DCHKPP  
subroutine  dchkps (DOTYPE, NN, NVAL, NNB, NBVAL, NRANK, RANKVAL, THRESH, TSTERR, NMAX, A, AFAC, PERM, PIV, WORK, RWORK, NOUT) 
DCHKPS  
subroutine  dchkpt (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT) 
DCHKPT  
subroutine  dchkq3 (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, THRESH, A, COPYA, S, TAU, WORK, IWORK, NOUT) 
DCHKQ3  
subroutine  dchkql (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, IWORK, NOUT) 
DCHKQL  
subroutine  dchkqp (DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK, IWORK, NOUT) 
DCHKQP  
subroutine  dchkqr (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) 
DCHKQR  
subroutine  dchkqrt (THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT) 
DCHKQRT  
subroutine  dchkqrtp (THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT) 
DCHKQRTP  
program  dchkrfp 
DCHKRFP  
subroutine  dchkrq (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) 
DCHKRQ  
subroutine  dchksp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DCHKSP  
subroutine  dchksy (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DCHKSY  
subroutine  dchktb (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AB, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DCHKTB  
subroutine  dchktp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AP, AINVP, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DCHKTP  
subroutine  dchktr (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DCHKTR  
subroutine  dchktz (DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK, NOUT) 
DCHKTZ  
subroutine  ddrvab (DOTYPE, NM, MVAL, NNS, NSVAL, THRESH, NMAX, A, AFAC, B, X, WORK, RWORK, SWORK, IWORK, NOUT) 
DDRVAB  
subroutine  ddrvac (DOTYPE, NM, MVAL, NNS, NSVAL, THRESH, NMAX, A, AFAC, B, X, WORK, RWORK, SWORK, NOUT) 
DDRVAC  
subroutine  ddrvgb (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, LA, AFB, LAFB, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
DDRVGB  
subroutine  ddrvge (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
DDRVGE  
subroutine  ddrvgt (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DDRVGT  
subroutine  ddrvls (DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB, NBVAL, NXVAL, THRESH, TSTERR, A, COPYA, B, COPYB, C, S, COPYS, WORK, IWORK, NOUT) 
DDRVLS  
subroutine  ddrvpb (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
DDRVPB  
subroutine  ddrvpo (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
DDRVPO  
subroutine  ddrvpp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
DDRVPP  
subroutine  ddrvpt (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT) 
DDRVPT  
subroutine  ddrvrf1 (NOUT, NN, NVAL, THRESH, A, LDA, ARF, WORK) 
DDRVRF1  
subroutine  ddrvrf2 (NOUT, NN, NVAL, A, LDA, ARF, AP, ASAV) 
DDRVRF2  
subroutine  ddrvrf3 (NOUT, NN, NVAL, THRESH, A, LDA, ARF, B1, B2, D_WORK_DLANGE, D_WORK_DGEQRF, TAU) 
DDRVRF3  
subroutine  ddrvrf4 (NOUT, NN, NVAL, THRESH, C1, C2, LDC, CRF, A, LDA, D_WORK_DLANGE) 
DDRVRF4  
subroutine  ddrvrfp (NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL, THRESH, A, ASAV, AFAC, AINV, B, BSAV, XACT, X, ARF, ARFINV, D_WORK_DLATMS, D_WORK_DPOT01, D_TEMP_DPOT02, D_TEMP_DPOT03, D_WORK_DLANSY, D_WORK_DPOT02, D_WORK_DPOT03) 
DDRVRFP  
subroutine  ddrvsp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DDRVSP  
subroutine  ddrvsy (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
DDRVSY  
subroutine  debchvxx (THRESH, PATH) 
DEBCHVXX  
subroutine  derrab (NUNIT) 
DERRAB  
subroutine  derrac (NUNIT) 
DERRAC  
subroutine  derrge (PATH, NUNIT) 
DERRGE  
subroutine  derrgt (PATH, NUNIT) 
DERRGT  
subroutine  derrlq (PATH, NUNIT) 
DERRLQ  
subroutine  derrls (PATH, NUNIT) 
DERRLS  
subroutine  derrpo (PATH, NUNIT) 
DERRPO  
subroutine  derrps (PATH, NUNIT) 
DERRPS  
subroutine  derrql (PATH, NUNIT) 
DERRQL  
subroutine  derrqp (PATH, NUNIT) 
DERRQP  
subroutine  derrqr (PATH, NUNIT) 
DERRQR  
subroutine  derrqrt (PATH, NUNIT) 
DERRQRT  
subroutine  derrqrtp (PATH, NUNIT) 
DERRQRTP  
subroutine  derrrfp (NUNIT) 
DERRRFP  
subroutine  derrrq (PATH, NUNIT) 
DERRRQ  
subroutine  derrsy (PATH, NUNIT) 
DERRSY  
subroutine  derrtr (PATH, NUNIT) 
DERRTR  
subroutine  derrtz (PATH, NUNIT) 
DERRTZ  
subroutine  derrvx (PATH, NUNIT) 
DERRVX  
subroutine  dgbt01 (M, N, KL, KU, A, LDA, AFAC, LDAFAC, IPIV, WORK, RESID) 
DGBT01  
subroutine  dgbt02 (TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, RESID) 
DGBT02  
subroutine  dgbt05 (TRANS, N, KL, KU, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
DGBT05  
subroutine  dgelqs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
DGELQS  
LOGICAL function  dgennd (M, N, A, LDA) 
DGENND  
subroutine  dgeqls (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
DGEQLS  
subroutine  dgeqrs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
DGEQRS  
subroutine  dgerqs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
DGERQS  
subroutine  dget01 (M, N, A, LDA, AFAC, LDAFAC, IPIV, RWORK, RESID) 
DGET01  
subroutine  dget02 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
DGET02  
subroutine  dget03 (N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID) 
DGET03  
subroutine  dget04 (N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID) 
DGET04  
DOUBLE PRECISION function  dget06 (RCOND, RCONDC) 
DGET06  
subroutine  dget07 (TRANS, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, CHKFERR, BERR, RESLTS) 
DGET07  
subroutine  dget08 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
DGET08  
subroutine  dgtt01 (N, DL, D, DU, DLF, DF, DUF, DU2, IPIV, WORK, LDWORK, RWORK, RESID) 
DGTT01  
subroutine  dgtt02 (TRANS, N, NRHS, DL, D, DU, X, LDX, B, LDB, RESID) 
DGTT02  
subroutine  dgtt05 (TRANS, N, NRHS, DL, D, DU, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
DGTT05  
subroutine  dlahilb (N, NRHS, A, LDA, X, LDX, B, LDB, WORK, INFO) 
DLAHILB  
subroutine  dlaord (JOB, N, X, INCX) 
DLAORD  
subroutine  dlaptm (N, NRHS, ALPHA, D, E, X, LDX, BETA, B, LDB) 
DLAPTM  
subroutine  dlarhs (PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO) 
DLARHS  
subroutine  dlatb4 (PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST) 
DLATB4  
subroutine  dlatb5 (PATH, IMAT, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST) 
DLATB5  
subroutine  dlattb (IMAT, UPLO, TRANS, DIAG, ISEED, N, KD, AB, LDAB, B, WORK, INFO) 
DLATTB  
subroutine  dlattp (IMAT, UPLO, TRANS, DIAG, ISEED, N, A, B, WORK, INFO) 
DLATTP  
subroutine  dlattr (IMAT, UPLO, TRANS, DIAG, ISEED, N, A, LDA, B, WORK, INFO) 
DLATTR  
subroutine  dlavsp (UPLO, TRANS, DIAG, N, NRHS, A, IPIV, B, LDB, INFO) 
DLAVSP  
subroutine  dlavsy (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO) 
DLAVSY  
subroutine  dlqt01 (M, N, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DLQT01  
subroutine  dlqt02 (M, N, K, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DLQT02  
subroutine  dlqt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DLQT03  
subroutine  dpbt01 (UPLO, N, KD, A, LDA, AFAC, LDAFAC, RWORK, RESID) 
DPBT01  
subroutine  dpbt02 (UPLO, N, KD, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
DPBT02  
subroutine  dpbt05 (UPLO, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
DPBT05  
subroutine  dpot01 (UPLO, N, A, LDA, AFAC, LDAFAC, RWORK, RESID) 
DPOT01  
subroutine  dpot02 (UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
DPOT02  
subroutine  dpot03 (UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID) 
DPOT03  
subroutine  dpot05 (UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
DPOT05  
subroutine  dpot06 (UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
DPOT06  
subroutine  dppt01 (UPLO, N, A, AFAC, RWORK, RESID) 
DPPT01  
subroutine  dppt02 (UPLO, N, NRHS, A, X, LDX, B, LDB, RWORK, RESID) 
DPPT02  
subroutine  dppt03 (UPLO, N, A, AINV, WORK, LDWORK, RWORK, RCOND, RESID) 
DPPT03  
subroutine  dppt05 (UPLO, N, NRHS, AP, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
DPPT05  
subroutine  dpst01 (UPLO, N, A, LDA, AFAC, LDAFAC, PERM, LDPERM, PIV, RWORK, RESID, RANK) 
DPST01  
subroutine  dptt01 (N, D, E, DF, EF, WORK, RESID) 
DPTT01  
subroutine  dptt02 (N, NRHS, D, E, X, LDX, B, LDB, RESID) 
DPTT02  
subroutine  dptt05 (N, NRHS, D, E, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
DPTT05  
subroutine  dqlt01 (M, N, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DQLT01  
subroutine  dqlt02 (M, N, K, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DQLT02  
subroutine  dqlt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DQLT03  
DOUBLE PRECISION function  dqpt01 (M, N, K, A, AF, LDA, TAU, JPVT, WORK, LWORK) 
DQPT01  
subroutine  dqrt01 (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DQRT01  
subroutine  dqrt01p (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DQRT01P  
subroutine  dqrt02 (M, N, K, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DQRT02  
subroutine  dqrt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DQRT03  
subroutine  dqrt04 (M, N, NB, RESULT) 
DQRT04  
subroutine  dqrt05 (M, N, L, NB, RESULT) 
DQRT05  
DOUBLE PRECISION function  dqrt11 (M, K, A, LDA, TAU, WORK, LWORK) 
DQRT11  
DOUBLE PRECISION function  dqrt12 (M, N, A, LDA, S, WORK, LWORK) 
DQRT12  
subroutine  dqrt13 (SCALE, M, N, A, LDA, NORMA, ISEED) 
DQRT13  
DOUBLE PRECISION function  dqrt14 (TRANS, M, N, NRHS, A, LDA, X, LDX, WORK, LWORK) 
DQRT14  
subroutine  dqrt15 (SCALE, RKSEL, M, N, NRHS, A, LDA, B, LDB, S, RANK, NORMA, NORMB, ISEED, WORK, LWORK) 
DQRT15  
subroutine  dqrt16 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
DQRT16  
DOUBLE PRECISION function  dqrt17 (TRANS, IRESID, M, N, NRHS, A, LDA, X, LDX, B, LDB, C, WORK, LWORK) 
DQRT17  
subroutine  drqt01 (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DRQT01  
subroutine  drqt02 (M, N, K, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DRQT02  
subroutine  drqt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
DRQT03  
DOUBLE PRECISION function  drzt01 (M, N, A, AF, LDA, TAU, WORK, LWORK) 
DRZT01  
DOUBLE PRECISION function  drzt02 (M, N, AF, LDA, TAU, WORK, LWORK) 
DRZT02  
subroutine  dspt01 (UPLO, N, A, AFAC, IPIV, C, LDC, RWORK, RESID) 
DSPT01  
subroutine  dsyt01 (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID) 
DSYT01  
subroutine  dtbt02 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, X, LDX, B, LDB, WORK, RESID) 
DTBT02  
subroutine  dtbt03 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, SCALE, CNORM, TSCAL, X, LDX, B, LDB, WORK, RESID) 
DTBT03  
subroutine  dtbt05 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
DTBT05  
subroutine  dtbt06 (RCOND, RCONDC, UPLO, DIAG, N, KD, AB, LDAB, WORK, RAT) 
DTBT06  
subroutine  dtpt01 (UPLO, DIAG, N, AP, AINVP, RCOND, WORK, RESID) 
DTPT01  
subroutine  dtpt02 (UPLO, TRANS, DIAG, N, NRHS, AP, X, LDX, B, LDB, WORK, RESID) 
DTPT02  
subroutine  dtpt03 (UPLO, TRANS, DIAG, N, NRHS, AP, SCALE, CNORM, TSCAL, X, LDX, B, LDB, WORK, RESID) 
DTPT03  
subroutine  dtpt05 (UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
DTPT05  
subroutine  dtpt06 (RCOND, RCONDC, UPLO, DIAG, N, AP, WORK, RAT) 
DTPT06  
subroutine  dtrt01 (UPLO, DIAG, N, A, LDA, AINV, LDAINV, RCOND, WORK, RESID) 
DTRT01  
subroutine  dtrt02 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, X, LDX, B, LDB, WORK, RESID) 
DTRT02  
subroutine  dtrt03 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, SCALE, CNORM, TSCAL, X, LDX, B, LDB, WORK, RESID) 
DTRT03  
subroutine  dtrt05 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
DTRT05  
subroutine  dtrt06 (RCOND, RCONDC, UPLO, DIAG, N, A, LDA, WORK, RAT) 
DTRT06  
DOUBLE PRECISION function  dtzt01 (M, N, A, AF, LDA, TAU, WORK, LWORK) 
DTZT01  
DOUBLE PRECISION function  dtzt02 (M, N, AF, LDA, TAU, WORK, LWORK) 
DTZT02 
This is the group of double LAPACK TESTING LIN routines.
program dchkaa  (  ) 
DCHKAA
DCHKAA is the main test program for the DOUBLE PRECISION LAPACK 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 40 lines: Data file for testing DOUBLE PRECISION LAPACK linear eqn. 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) 20.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 DGE 11 List types on next line if 0 < NTYPES < 11 DGB 8 List types on next line if 0 < NTYPES < 8 DGT 12 List types on next line if 0 < NTYPES < 12 DPO 9 List types on next line if 0 < NTYPES < 9 DPS 9 List types on next line if 0 < NTYPES < 9 DPP 9 List types on next line if 0 < NTYPES < 9 DPB 8 List types on next line if 0 < NTYPES < 8 DPT 12 List types on next line if 0 < NTYPES < 12 DSY 10 List types on next line if 0 < NTYPES < 10 DSR 10 List types on next line if 0 < NTYPES < 10 DSP 10 List types on next line if 0 < NTYPES < 10 DTR 18 List types on next line if 0 < NTYPES < 18 DTP 18 List types on next line if 0 < NTYPES < 18 DTB 17 List types on next line if 0 < NTYPES < 17 DQR 8 List types on next line if 0 < NTYPES < 8 DRQ 8 List types on next line if 0 < NTYPES < 8 DLQ 8 List types on next line if 0 < NTYPES < 8 DQL 8 List types on next line if 0 < NTYPES < 8 DQP 6 List types on next line if 0 < NTYPES < 6 DTZ 3 List types on next line if 0 < NTYPES < 3 DLS 6 List types on next line if 0 < NTYPES < 6 DEQ DQT DQX
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 107 of file dchkaa.f.
program dchkab  (  ) 
DCHKAB
DCHKAB is the test program for the DOUBLE PRECISION LAPACK DSGESV/DSPOSV routine The program must be driven by a short data file. The first 5 records specify problem dimensions and program options using listdirected input. The remaining lines specify the LAPACK test paths and the number of matrix types to use in testing. An annotated example of a data file can be obtained by deleting the first 3 characters from the following 10 lines: Data file for testing DOUBLE PRECISION LAPACK DSGESV 7 Number of values of M 0 1 2 3 5 10 16 Values of M (row dimension) 1 Number of values of NRHS 2 Values of NRHS (number of right hand sides) 20.0 Threshold value of test ratio T Put T to test the LAPACK routines T Put T to test the error exits DGE 11 List types on next line if 0 < NTYPES < 11 DPO 9 List types on next line if 0 < NTYPES < 9
NMAX INTEGER The maximum allowable value for N MAXIN INTEGER The number of different values that can be used for each of M, N, NRHS, NB, and NX MAXRHS INTEGER The maximum number of right hand sides NIN INTEGER The unit number for input NOUT INTEGER The unit number for output
Definition at line 74 of file dchkab.f.
subroutine dchkeq  (  double precision  THRESH, 
integer  NOUT  
) 
DCHKEQ
DCHKEQ tests DGEEQU, DGBEQU, DPOEQU, DPPEQU and DPBEQU
[in]  THRESH  THRESH is DOUBLE PRECISION Threshold for testing routines. Should be between 2 and 10. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 55 of file dchkeq.f.
subroutine dchkgb  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
double precision, dimension( * )  A,  
integer  LA,  
double precision, dimension( * )  AFAC,  
integer  LAFAC,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKGB
DCHKGB tests DGBTRF, 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 DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX,NMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 190 of file dchkgb.f.
subroutine dchkge  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  AINV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKGE
DCHKGE tests DGETRF, TRI, TRS, RFS, and CON.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(2*NMAX,2*NSMAX+NWORK)) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 184 of file dchkge.f.
subroutine dchkgt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AF,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKGT
DCHKGT tests DGTTRF, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*4) 
[out]  AF  AF is DOUBLE PRECISION array, dimension (NMAX*4) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 146 of file dchkgt.f.
subroutine dchklq  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AF,  
double precision, dimension( * )  AQ,  
double precision, dimension( * )  AL,  
double precision, dimension( * )  AC,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  TAU,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer  NOUT  
) 
DCHKLQ
DCHKLQ tests DGELQF, DORGLQ and DORMLQ.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AF  AF is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AL  AL is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AC  AC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 195 of file dchklq.f.
subroutine dchkpb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  AINV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKPB
DCHKPB tests DPBTRF, TRS, RFS, and CON.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 171 of file dchkpb.f.
subroutine dchkpo  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  AINV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKPO
DCHKPO tests DPOTRF, TRI, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 171 of file dchkpo.f.
subroutine dchkpp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  AINV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKPP
DCHKPP tests DPPTRF, TRI, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 162 of file dchkpp.f.
subroutine dchkps  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NRANK,  
integer, dimension( * )  RANKVAL,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  PERM,  
integer, dimension( * )  PIV,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer  NOUT  
) 
DCHKPS
DCHKPS tests DPSTRF.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the block size NB. 
[in]  NRANK  NRANK is INTEGER The number of values of RANK contained in the vector RANKVAL. 
[in]  RANKVAL  RANKVAL is INTEGER array, dimension (NBVAL) The values of the block size NB. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  PERM  PERM is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  PIV  PIV is INTEGER array, dimension (NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*3) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 153 of file dchkps.f.
subroutine dchkpt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
double precision, dimension( * )  A,  
double precision, dimension( * )  D,  
double precision, dimension( * )  E,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer  NOUT  
) 
DCHKPT
DCHKPT tests DPTTRF, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*2) 
[out]  D  D is DOUBLE PRECISION array, dimension (NMAX*2) 
[out]  E  E is DOUBLE PRECISION array, dimension (NMAX*2) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 146 of file dchkpt.f.
subroutine dchkq3  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
double precision  THRESH,  
double precision, dimension( * )  A,  
double precision, dimension( * )  COPYA,  
double precision, dimension( * )  S,  
double precision, dimension( * )  TAU,  
double precision, dimension( * )  WORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKQ3
DCHKQ3 tests DGEQP3.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[out]  A  A is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (MMAX*NMAX) 
[out]  S  S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is DOUBLE PRECISION array, dimension (MMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (MMAX*NMAX + 4*NMAX + MMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 152 of file dchkq3.f.
subroutine dchkql  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AF,  
double precision, dimension( * )  AQ,  
double precision, dimension( * )  AL,  
double precision, dimension( * )  AC,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  TAU,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKQL
DCHKQL tests DGEQLF, DORGQL and DORMQL.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AF  AF is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AL  AL is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AC  AC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 200 of file dchkql.f.
subroutine dchkqp  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
double precision  THRESH,  
logical  TSTERR,  
double precision, dimension( * )  A,  
double precision, dimension( * )  COPYA,  
double precision, dimension( * )  S,  
double precision, dimension( * )  TAU,  
double precision, dimension( * )  WORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKQP
DCHKQP tests DGEQPF.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (MMAX*NMAX) 
[out]  S  S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is DOUBLE PRECISION array, dimension (MMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (MMAX*NMAX + 4*NMAX + MMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 137 of file dchkqp.f.
subroutine dchkqr  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AF,  
double precision, dimension( * )  AQ,  
double precision, dimension( * )  AR,  
double precision, dimension( * )  AC,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  TAU,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKQR
DCHKQR tests DGEQRF, DORGQR and DORMQR.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AF  AF is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AR  AR is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AC  AC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 200 of file dchkqr.f.
subroutine dchkqrt  (  double precision  THRESH, 
logical  TSTERR,  
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NOUT  
) 
DCHKQRT
DCHKQRT tests DGEQRT and DGEMQRT.
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 102 of file dchkqrt.f.
subroutine dchkqrtp  (  double precision  THRESH, 
logical  TSTERR,  
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NOUT  
) 
DCHKQRTP
DCHKQRTP tests DTPQRT and DTPMQRT.
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 102 of file dchkqrtp.f.
program dchkrfp  (  ) 
DCHKRFP
DCHKRFP is the main test program for the DOUBLE PRECISION 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 dchkrfp.f.
subroutine dchkrq  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AF,  
double precision, dimension( * )  AQ,  
double precision, dimension( * )  AR,  
double precision, dimension( * )  AC,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  TAU,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKRQ
DCHKRQ tests DGERQF, DORGRQ and DORMRQ.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AF  AF is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AR  AR is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AC  AC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 200 of file dchkrq.f.
subroutine dchksp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  AINV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKSP
DCHKSP tests DSPTRF, TRI, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(2,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NSMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 162 of file dchksp.f.
subroutine dchksy  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  AINV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKSY
DCHKSY tests DSYTRF, TRI2, TRS, TRS2, RFS, and CON.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 171 of file dchksy.f.
subroutine dchktb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  AB,  
double precision, dimension( * )  AINV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKTB
DCHKTB tests DTBTRS, RFS, and CON, and DLATBS.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximum value of N in NVAL. 
[out]  AB  AB is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 154 of file dchktb.f.
subroutine dchktp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  AP,  
double precision, dimension( * )  AINVP,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKTP
DCHKTP tests DTPTRI, TRS, RFS, and CON, and DLATPS
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximumm value of N in NVAL. 
[out]  AP  AP is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINVP  AINVP is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 156 of file dchktp.f.
subroutine dchktr  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AINV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DCHKTR
DCHKTR tests DTRTRI, TRS, RFS, and CON, and DLATRS
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximum value of N in NVAL. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 166 of file dchktr.f.
subroutine dchktz  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
double precision  THRESH,  
logical  TSTERR,  
double precision, dimension( * )  A,  
double precision, dimension( * )  COPYA,  
double precision, dimension( * )  S,  
double precision, dimension( * )  TAU,  
double precision, dimension( * )  WORK,  
integer  NOUT  
) 
DCHKTZ
DCHKTZ tests DTZRQF and STZRZF.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (MMAX*NMAX) 
[out]  S  S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is DOUBLE PRECISION array, dimension (MMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (MMAX*NMAX + 4*NMAX + MMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 132 of file dchktz.f.
subroutine ddrvab  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
real, dimension(*)  SWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DDRVAB
DDRVAB tests DSGESV
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(2*NMAX,2*NSMAX+NWORK)) 
[out]  SWORK  SWORK is REAL array, dimension (NMAX*(NSMAX+NMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension NMAX 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 150 of file ddrvab.f.
subroutine ddrvac  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
double precision  THRESH,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
real, dimension(*)  SWORK,  
integer  NOUT  
) 
DDRVAC
DDRVAC tests DSPOSV.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of N contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(2*NMAX,2*NSMAX+NWORK)) 
[out]  SWORK  SWORK is REAL array, dimension (NMAX*(NSMAX+NMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 143 of file ddrvac.f.
subroutine ddrvgb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
double precision, dimension( * )  A,  
integer  LA,  
double precision, dimension( * )  AFB,  
integer  LAFB,  
double precision, dimension( * )  ASAV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  BSAV,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  S,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DDRVGB
DDRVGBX
DDRVGB tests the driver routines DGBSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LA) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (2*NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NRHS,NMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NRHS)) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
DDRVGB tests the driver routines DGBSV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise ddrvgb.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LA) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (2*NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NRHS,NMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NRHS)) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 171 of file ddrvgb.f.
subroutine ddrvge  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  ASAV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  BSAV,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  S,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DDRVGE
DDRVGEX
DDRVGE tests the driver routines DGESV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (2*NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (2*NRHS+NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
DDRVGE tests the driver routines DGESV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise ddrvge.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (2*NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (2*NRHS+NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 163 of file ddrvge.f.
subroutine ddrvgt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AF,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DDRVGT
DDRVGT tests DGTSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, NRHS >= 0. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*4) 
[out]  AF  AF is DOUBLE PRECISION array, dimension (NMAX*4) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(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 ddrvgt.f.
subroutine ddrvls  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
double precision  THRESH,  
logical  TSTERR,  
double precision, dimension( * )  A,  
double precision, dimension( * )  COPYA,  
double precision, dimension( * )  B,  
double precision, dimension( * )  COPYB,  
double precision, dimension( * )  C,  
double precision, dimension( * )  S,  
double precision, dimension( * )  COPYS,  
double precision, dimension( * )  WORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DDRVLS
DDRVLS tests the least squares driver routines DGELS, DGELSS, DGELSX, DGELSY and DGELSD.
[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 orthogonal 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 orthogonal 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]  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]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (MMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (MMAX*NSMAX) 
[out]  C  C is DOUBLE PRECISION array, dimension (MMAX*NSMAX) 
[out]  S  S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX)) 
[out]  COPYS  COPYS is DOUBLE PRECISION array, dimension (min(MMAX,NMAX)) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (MMAX*NMAX + 4*NMAX + MMAX). 
[out]  IWORK  IWORK is INTEGER array, dimension (15*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 202 of file ddrvls.f.
subroutine ddrvpb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  ASAV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  BSAV,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  S,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DDRVPB
DDRVPB tests the driver routines DPBSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 163 of file ddrvpb.f.
subroutine ddrvpo  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  ASAV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  BSAV,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  S,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DDRVPO
DDRVPOX
DDRVPO tests the driver routines DPOSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
DDRVPO tests the driver routines DPOSV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise ddrvpo.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 163 of file ddrvpo.f.
subroutine ddrvpp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  ASAV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  BSAV,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  S,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DDRVPP
DDRVPP tests the driver routines DPPSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  ASAV  ASAV is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 166 of file ddrvpp.f.
subroutine ddrvpt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
double precision, dimension( * )  A,  
double precision, dimension( * )  D,  
double precision, dimension( * )  E,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer  NOUT  
) 
DDRVPT
DDRVPT tests DPTSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*2) 
[out]  D  D is DOUBLE PRECISION array, dimension (NMAX*2) 
[out]  E  E is DOUBLE PRECISION array, dimension (NMAX*2) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NRHS)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 140 of file ddrvpt.f.
subroutine ddrvrf1  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
double precision  THRESH,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( * )  ARF,  
double precision, dimension( * )  WORK  
) 
DDRVRF1
DDRVRF1 tests the LAPACK RFP routines: DLANSF
[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 DOUBLE PRECISION array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  ARF  ARF is DOUBLE PRECISION array, dimension ((NMAX*(NMAX+1))/2). 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension ( NMAX ) 
Definition at line 95 of file ddrvrf1.f.
subroutine ddrvrf2  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( * )  ARF,  
double precision, dimension(*)  AP,  
double precision, dimension( lda, * )  ASAV  
) 
DDRVRF2
DDRVRF2 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 DOUBLE PRECISION array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  ARF  ARF is DOUBLE PRECISION array, dimension ((NMAX*(NMAX+1))/2). 
[out]  AP  AP is DOUBLE PRECISION array, dimension ((NMAX*(NMAX+1))/2). 
[out]  ASAV  ASAV is DOUBLE PRECISION array, dimension (LDA,NMAX) 
Definition at line 90 of file ddrvrf2.f.
subroutine ddrvrf3  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
double precision  THRESH,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( * )  ARF,  
double precision, dimension( lda, * )  B1,  
double precision, dimension( lda, * )  B2,  
double precision, dimension( * )  D_WORK_DLANGE,  
double precision, dimension( * )  D_WORK_DGEQRF,  
double precision, dimension( * )  TAU  
) 
DDRVRF3
DDRVRF3 tests the LAPACK RFP routines: DTFSM
[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 DOUBLE PRECISION array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  ARF  ARF is DOUBLE PRECISION array, dimension ((NMAX*(NMAX+1))/2). 
[out]  B1  B1 is DOUBLE PRECISION array, dimension (LDA,NMAX) 
[out]  B2  B2 is DOUBLE PRECISION array, dimension (LDA,NMAX) 
[out]  D_WORK_DLANGE  D_WORK_DLANGE is DOUBLE PRECISION array, dimension (NMAX) 
[out]  D_WORK_DGEQRF  D_WORK_DGEQRF is DOUBLE PRECISION array, dimension (NMAX) 
[out]  TAU  TAU is DOUBLE PRECISION array, dimension (NMAX) 
Definition at line 118 of file ddrvrf3.f.
subroutine ddrvrf4  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
double precision  THRESH,  
double precision, dimension( ldc, * )  C1,  
double precision, dimension( ldc, *)  C2,  
integer  LDC,  
double precision, dimension( * )  CRF,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( * )  D_WORK_DLANGE  
) 
DDRVRF4
DDRVRF4 tests the LAPACK RFP routines: DSFRK
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[out]  C1  C1 is DOUBLE PRECISION array, dimension (LDC,NMAX) 
[out]  C2  C2 is DOUBLE PRECISION array, dimension (LDC,NMAX) 
[in]  LDC  LDC is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  CRF  CRF is DOUBLE PRECISION array, dimension ((NMAX*(NMAX+1))/2). 
[out]  A  A is DOUBLE PRECISION array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  D_WORK_DLANGE  D_WORK_DLANGE is DOUBLE PRECISION array, dimension (NMAX) 
Definition at line 118 of file ddrvrf4.f.
subroutine ddrvrfp  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
integer  NNS,  
integer, dimension( nns )  NSVAL,  
integer  NNT,  
integer, dimension( nnt )  NTVAL,  
double precision  THRESH,  
double precision, dimension( * )  A,  
double precision, dimension( * )  ASAV,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  AINV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  BSAV,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  X,  
double precision, dimension( * )  ARF,  
double precision, dimension( * )  ARFINV,  
double precision, dimension( * )  D_WORK_DLATMS,  
double precision, dimension( * )  D_WORK_DPOT01,  
double precision, dimension( * )  D_TEMP_DPOT02,  
double precision, dimension( * )  D_TEMP_DPOT03,  
double precision, dimension( * )  D_WORK_DLANSY,  
double precision, dimension( * )  D_WORK_DPOT02,  
double precision, dimension( * )  D_WORK_DPOT03  
) 
DDRVRFP
DDRVRFP tests the LAPACK RFP routines: DPFTRF, DPFTRS, and DPFTRI. This testing routine follow the same tests as DDRVPO (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 DTRTTF and DTFTTR. 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 DPFTRF, no test ratios are computed) A solution XACT of size NbyNRHS is created and the associated right hand side B as well. Then DPFTRF is called to compute L (or U), the Cholesky factor of A. Then L (or U) is used to solve the linear system of equations AX = B. This gives X. Then L (or U) is used to compute the inverse of A, AINV. The following four tests are then performed: (1) norm( L*L'  A ) / ( N * norm(A) * EPS ) or norm( U'*U  A ) / ( N * norm(A) * EPS ), (2) norm(B  A*X) / ( norm(A) * norm(X) * EPS ), (3) norm( I  A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ), (4) ( norm(XXACT) * RCOND ) / ( norm(XACT) * EPS ), where EPS is the machine precision, RCOND the condition number of A, and norm( . ) the 1norm for (1,2,3) and the infnorm for (4). Errors occur when INFO parameter is not as expected. Failures occur when a test ratios is greater than THRES.
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of righthand sides NRHS. 
[in]  NNT  NNT is INTEGER The number of values of MATRIX TYPE contained in the vector NTVAL. 
[in]  NTVAL  NTVAL is INTEGER array, dimension (NNT) The values of matrix type (between 0 and 9 for PO/PP/PF matrices). 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*MAXRHS) 
[out]  BSAV  BSAV is DOUBLE PRECISION array, dimension (NMAX*MAXRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*MAXRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*MAXRHS) 
[out]  ARF  ARF is DOUBLE PRECISION array, dimension ((NMAX*(NMAX+1))/2) 
[out]  ARFINV  ARFINV is DOUBLE PRECISION array, dimension ((NMAX*(NMAX+1))/2) 
[out]  D_WORK_DLATMS  D_WORK_DLATMS is DOUBLE PRECISION array, dimension ( 3*NMAX ) 
[out]  D_WORK_DPOT01  D_WORK_DPOT01 is DOUBLE PRECISION array, dimension ( NMAX ) 
[out]  D_TEMP_DPOT02  D_TEMP_DPOT02 is DOUBLE PRECISION array, dimension ( NMAX*MAXRHS ) 
[out]  D_TEMP_DPOT03  D_TEMP_DPOT03 is DOUBLE PRECISION array, dimension ( NMAX*NMAX ) 
[out]  D_WORK_DLATMS  D_WORK_DLATMS is DOUBLE PRECISION array, dimension ( NMAX ) 
[out]  D_WORK_DLANSY  D_WORK_DLANSY is DOUBLE PRECISION array, dimension ( NMAX ) 
[out]  D_WORK_DPOT02  D_WORK_DPOT02 is DOUBLE PRECISION array, dimension ( NMAX ) 
[out]  D_WORK_DPOT03  D_WORK_DPOT03 is DOUBLE PRECISION array, dimension ( NMAX ) 
Definition at line 239 of file ddrvrfp.f.
subroutine ddrvsp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  AINV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DDRVSP
DDRVSP tests the driver routines DSPSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 155 of file ddrvsp.f.
subroutine ddrvsy  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
double precision  THRESH,  
logical  TSTERR,  
integer  NMAX,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  AINV,  
double precision, dimension( * )  B,  
double precision, dimension( * )  X,  
double precision, dimension( * )  XACT,  
double precision, dimension( * )  WORK,  
double precision, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
DDRVSY
DDRVSYX
DDRVSY tests the driver routines DSYSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
DDRVSY tests the driver routines DSYSV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise ddrvsy.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 152 of file ddrvsy.f.
subroutine debchvxx  (  double precision  THRESH, 
character*3  PATH  
) 
DEBCHVXX
DEBCHVXX will run D**SVXX on a series of Hilbert matrices and then compare the error bounds returned by D**SVXX to see if the returned answer indeed falls within those bounds. Eight test ratios will be computed. The tests will pass if they are .LT. THRESH. There are two cases that are determined by 1 / (SQRT( N ) * EPS). If that value is .LE. to the component wise reciprocal condition number, it uses the guaranteed case, other wise it uses the unguaranteed case. Test ratios: Let Xc be X_computed and Xt be X_truth. The norm used is the infinity norm. Let A be the guaranteed case and B be the unguaranteed case. 1. Normwise guaranteed forward error bound. A: norm ( abs( Xc  Xt ) / norm ( Xt ) .LE. ERRBND( *, nwise_i, bnd_i ) and ERRBND( *, nwise_i, bnd_i ) .LE. MAX(SQRT(N),10) * EPS. If these conditions are met, the test ratio is set to be ERRBND( *, nwise_i, bnd_i ) / MAX(SQRT(N), 10). Otherwise it is 1/EPS. B: For this case, CGESVXX should just return 1. If it is less than one, treat it the same as in 1A. Otherwise it fails. (Set test ratio to ERRBND( *, nwise_i, bnd_i ) * THRESH?) 2. Componentwise guaranteed forward error bound. A: norm ( abs( Xc(j)  Xt(j) ) ) / norm (Xt(j)) .LE. ERRBND( *, cwise_i, bnd_i ) for all j .AND. ERRBND( *, cwise_i, bnd_i ) .LE. MAX(SQRT(N), 10) * EPS. If these conditions are met, the test ratio is set to be ERRBND( *, cwise_i, bnd_i ) / MAX(SQRT(N), 10). Otherwise it is 1/EPS. B: Same as normwise test ratio. 3. Backwards error. A: The test ratio is set to BERR/EPS. B: Same test ratio. 4. Reciprocal condition number. A: A condition number is computed with Xt and compared with the one returned from CGESVXX. Let RCONDc be the RCOND returned by D**SVXX 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 debchvxx.f.
subroutine derrab  (  integer  NUNIT  ) 
subroutine derrac  (  integer  NUNIT  ) 
subroutine derrge  (  character*3  PATH, 
integer  NUNIT  
) 
DERRGE
DERRGEX
DERRGE tests the error exits for the DOUBLE PRECISION 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. 
DERRGE tests the error exits for the DOUBLE PRECISION routines for general matrices. Note that this file is used only when the XBLAS are available, otherwise derrge.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 derrge.f.
subroutine derrgt  (  character*3  PATH, 
integer  NUNIT  
) 
DERRGT
DERRGT tests the error exits for the DOUBLE PRECISION 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 derrgt.f.
subroutine derrlq  (  character*3  PATH, 
integer  NUNIT  
) 
DERRLQ
DERRLQ tests the error exits for the DOUBLE PRECISION 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 derrlq.f.
subroutine derrls  (  character*3  PATH, 
integer  NUNIT  
) 
DERRLS
DERRLS tests the error exits for the DOUBLE PRECISION least squares driver routines (DGELS, SGELSS, SGELSX, SGELSY, SGELSD).
[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 derrls.f.
subroutine derrpo  (  character*3  PATH, 
integer  NUNIT  
) 
DERRPO
DERRPOX
DERRPO tests the error exits for the DOUBLE PRECISION routines for symmetric 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. 
DERRPO tests the error exits for the DOUBLE PRECISION routines for symmetric positive definite matrices. Note that this file is used only when the XBLAS are available, otherwise derrpo.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 derrpo.f.
subroutine derrps  (  character*3  PATH, 
integer  NUNIT  
) 
DERRPS
DERRPS tests the error exits for the DOUBLE PRECISION routines for DPSTRF.
[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 derrps.f.
subroutine derrql  (  character*3  PATH, 
integer  NUNIT  
) 
DERRQL
DERRQL tests the error exits for the DOUBLE PRECISION 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 derrql.f.
subroutine derrqp  (  character*3  PATH, 
integer  NUNIT  
) 
DERRQP
DERRQP tests the error exits for DGEQPF and DGEQP3.
[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 derrqp.f.
subroutine derrqr  (  character*3  PATH, 
integer  NUNIT  
) 
DERRQR
DERRQR tests the error exits for the DOUBLE PRECISION 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 derrqr.f.
subroutine derrqrt  (  character*3  PATH, 
integer  NUNIT  
) 
DERRQRT
DERRQRT tests the error exits for the DOUBLE PRECISION 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 derrqrt.f.
subroutine derrqrtp  (  character*3  PATH, 
integer  NUNIT  
) 
DERRQRTP
DERRQRTP 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 derrqrtp.f.
subroutine derrrfp  (  integer  NUNIT  ) 
DERRRFP
DERRRFP tests the error exits for the DOUBLE PRECISION driver routines for solving linear systems of equations. DDRVRFP tests the DOUBLE PRECISION LAPACK RFP routines: DTFSM, DTFTRI, DSFRK, DTFTTP, DTFTTR, DPFTRF, DPFTRS, DTPTTF, DTPTTR, DTRTTF, and DTRTTP
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 53 of file derrrfp.f.
subroutine derrrq  (  character*3  PATH, 
integer  NUNIT  
) 
DERRRQ
DERRRQ tests the error exits for the DOUBLE PRECISION 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 derrrq.f.
subroutine derrsy  (  character*3  PATH, 
integer  NUNIT  
) 
DERRSY
DERRSYX
DERRSY tests the error exits for the DOUBLE PRECISION 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. 
DERRSY tests the error exits for the DOUBLE PRECISION routines for symmetric indefinite matrices. Note that this file is used only when the XBLAS are available, otherwise derrsy.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 derrsy.f.
subroutine derrtr  (  character*3  PATH, 
integer  NUNIT  
) 
DERRTR
DERRTR tests the error exits for the DOUBLE PRECISION 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 56 of file derrtr.f.
subroutine derrtz  (  character*3  PATH, 
integer  NUNIT  
) 
DERRTZ
DERRTZ tests the error exits for DTZRQF and STZRZF.
[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 derrtz.f.
subroutine derrvx  (  character*3  PATH, 
integer  NUNIT  
) 
DERRVX
DERRVXX
DERRVX tests the error exits for the DOUBLE PRECISION 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. 
DERRVX tests the error exits for the DOUBLE PRECISION 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 derrvx.f.
subroutine dgbt01  (  integer  M, 
integer  N,  
integer  KL,  
integer  KU,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
integer, dimension( * )  IPIV,  
double precision, dimension( * )  WORK,  
double precision  RESID  
) 
DGBT01
DGBT01 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DGBTRF. 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 DGBTRF 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 DGBTRF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (2*KL+KU+1) 
[out]  RESID  RESID is DOUBLE PRECISION norm(L*U  A) / ( N * norm(A) * EPS ) 
Definition at line 126 of file dgbt01.f.
subroutine dgbt02  (  character  TRANS, 
integer  M,  
integer  N,  
integer  KL,  
integer  KU,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision  RESID  
) 
DGBT02
DGBT02 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N). 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 139 of file dgbt02.f.
subroutine dgbt05  (  character  TRANS, 
integer  N,  
integer  KL,  
integer  KU,  
integer  NRHS,  
double precision, dimension( ldab, * )  AB,  
integer  LDAB,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
double precision, dimension( * )  FERR,  
double precision, dimension( * )  BERR,  
double precision, dimension( * )  RESLTS  
) 
DGBT05
DGBT05 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 176 of file dgbt05.f.
subroutine dgelqs  (  integer  M, 
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
DGELQS
Compute a minimumnorm solution min  A*X  B  using the LQ factorization A = L*Q computed by DGELQF.
[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 DOUBLE PRECISION array, dimension (LDA,N) Details of the LQ factorization of the original matrix A as returned by DGELQF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is DOUBLE PRECISION array, dimension (M) Details of the orthogonal matrix Q. 
[in,out]  B  B is DOUBLE PRECISION 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 DOUBLE PRECISION 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 dgelqs.f.
LOGICAL function dgennd  (  integer  M, 
integer  N,  
double precision, dimension( lda, * )  A,  
integer  LDA  
) 
DGENND
DGENND tests that its argument has a 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 DOUBLE PRECISION array, dimension (LDA, N) The matrix. 
[in]  LDA  LDA is INTEGER Leading dimension of A. 
Definition at line 69 of file dgennd.f.
subroutine dgeqls  (  integer  M, 
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
DGEQLS
Solve the least squares problem min  A*X  B  using the QL factorization A = Q*L computed by DGEQLF.
[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 DOUBLE PRECISION array, dimension (LDA,N) Details of the QL factorization of the original matrix A as returned by DGEQLF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is DOUBLE PRECISION array, dimension (N) Details of the orthogonal matrix Q. 
[in,out]  B  B is DOUBLE PRECISION 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 DOUBLE PRECISION 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 dgeqls.f.
subroutine dgeqrs  (  integer  M, 
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
DGEQRS
Solve the least squares problem min  A*X  B  using the QR factorization A = Q*R computed by DGEQRF.
[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 DOUBLE PRECISION array, dimension (LDA,N) Details of the QR factorization of the original matrix A as returned by DGEQRF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is DOUBLE PRECISION array, dimension (N) Details of the orthogonal matrix Q. 
[in,out]  B  B is DOUBLE PRECISION 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 DOUBLE PRECISION 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 dgeqrs.f.
subroutine dgerqs  (  integer  M, 
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
DGERQS
Compute a minimumnorm solution min  A*X  B  using the RQ factorization A = R*Q computed by DGERQF.
[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 DOUBLE PRECISION array, dimension (LDA,N) Details of the RQ factorization of the original matrix A as returned by DGERQF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is DOUBLE PRECISION array, dimension (M) Details of the orthogonal matrix Q. 
[in,out]  B  B is DOUBLE PRECISION 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 DOUBLE PRECISION 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 dgerqs.f.
subroutine dget01  (  integer  M, 
integer  N,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
integer, dimension( * )  IPIV,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DGET01
DGET01 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DGETRF. 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 DGETRF. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESID  RESID is DOUBLE PRECISION norm(L*U  A) / ( N * norm(A) * EPS ) 
Definition at line 107 of file dget01.f.
subroutine dget02  (  character  TRANS, 
integer  M,  
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DGET02
DGET02 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'*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]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 133 of file dget02.f.
subroutine dget03  (  integer  N, 
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldainv, * )  AINV,  
integer  LDAINV,  
double precision, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
double precision, dimension( * )  RWORK,  
double precision  RCOND,  
double precision  RESID  
) 
DGET03
DGET03 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RCOND  RCOND is DOUBLE PRECISION The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is DOUBLE PRECISION norm(I  AINV*A) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 109 of file dget03.f.
subroutine dget04  (  integer  N, 
integer  NRHS,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
double precision  RCOND,  
double precision  RESID  
) 
DGET04
DGET04 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension( LDX, NRHS ) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  RCOND  RCOND is DOUBLE PRECISION The reciprocal of the condition number of the coefficient matrix in the system of equations. 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the NRHS solution vectors of ( norm(XXACT) * RCOND ) / ( norm(XACT) * EPS ) 
Definition at line 103 of file dget04.f.
DOUBLE PRECISION function dget06  (  double precision  RCOND, 
double precision  RCONDC  
) 
DGET06
DGET06 computes a test ratio to compare two values for RCOND.
[in]  RCOND  RCOND is DOUBLE PRECISION The estimate of the reciprocal of the condition number of A, as computed by DGECON. 
[in]  RCONDC  RCONDC is DOUBLE PRECISION The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(inv(A)). 
Definition at line 56 of file dget06.f.
subroutine dget07  (  character  TRANS, 
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
double precision, dimension( * )  FERR,  
logical  CHKFERR,  
double precision, dimension( * )  BERR,  
double precision, dimension( * )  RESLTS  
) 
DGET07
DGET07 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  CHKFERR  CHKFERR is LOGICAL Set to .TRUE. to check FERR, .FALSE. not to check FERR. When the test system is illconditioned, the "true" solution in XACT may be incorrect. 
[in]  BERR  BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) ) 
Definition at line 165 of file dget07.f.
subroutine dget08  (  character  TRANS, 
integer  M,  
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DGET08
DGET08 computes the residual for a solution of a system of linear equations A*x = b or A'*x = b: RESID = norm(B  A*X,inf) / ( norm(A,inf) * norm(X,inf) * 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'*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]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 133 of file dget08.f.
subroutine dgtt01  (  integer  N, 
double precision, dimension( * )  DL,  
double precision, dimension( * )  D,  
double precision, dimension( * )  DU,  
double precision, dimension( * )  DLF,  
double precision, dimension( * )  DF,  
double precision, dimension( * )  DUF,  
double precision, dimension( * )  DU2,  
integer, dimension( * )  IPIV,  
double precision, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DGTT01
DGTT01 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 DOUBLE PRECISION array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is DOUBLE PRECISION array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is DOUBLE PRECISION array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  DLF  DLF is DOUBLE PRECISION array, dimension (N1) The (n1) multipliers that define the matrix L from the LU factorization of A. 
[in]  DF  DF is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the upper triangular matrix U from the LU factorization of A. 
[in]  DUF  DUF is DOUBLE PRECISION array, dimension (N1) The (n1) elements of the first superdiagonal of U. 
[in]  DU2  DU2 is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The scaled residual: norm(L*U  A) / (norm(A) * EPS) 
Definition at line 134 of file dgtt01.f.
subroutine dgtt02  (  character  TRANS, 
integer  N,  
integer  NRHS,  
double precision, dimension( * )  DL,  
double precision, dimension( * )  D,  
double precision, dimension( * )  DU,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision  RESID  
) 
DGTT02
DGTT02 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'* X (Transpose) = 'C': B  A'* X (Conjugate transpose = 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 DOUBLE PRECISION array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is DOUBLE PRECISION array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is DOUBLE PRECISION array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  X  X is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  op(A)*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RESID  RESID is DOUBLE PRECISION norm(B  op(A)*X) / (norm(A) * norm(X) * EPS) 
Definition at line 124 of file dgtt02.f.
subroutine dgtt05  (  character  TRANS, 
integer  N,  
integer  NRHS,  
double precision, dimension( * )  DL,  
double precision, dimension( * )  D,  
double precision, dimension( * )  DU,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
double precision, dimension( * )  FERR,  
double precision, dimension( * )  BERR,  
double precision, dimension( * )  RESLTS  
) 
DGTT05
DGTT05 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 DOUBLE PRECISION array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is DOUBLE PRECISION array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is DOUBLE PRECISION array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  B  B is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 165 of file dgtt05.f.
subroutine dlahilb  (  integer  N, 
integer  NRHS,  
double precision, dimension(lda, n)  A,  
integer  LDA,  
double precision, dimension(ldx, nrhs)  X,  
integer  LDX,  
double precision, dimension(ldb, nrhs)  B,  
integer  LDB,  
double precision, dimension(n)  WORK,  
integer  INFO  
) 
DLAHILB
DLAHILB 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 
Definition at line 125 of file dlahilb.f.
subroutine dlaord  (  character  JOB, 
integer  N,  
double precision, dimension( * )  X,  
integer  INCX  
) 
DLAORD
DLAORD sorts the elements of a vector x in increasing or decreasing order.
[in]  JOB  JOB is CHARACTER = 'I': Sort in increasing order = 'D': Sort in decreasing order 
[in]  N  N is INTEGER The length of the vector X. 
[in,out]  X  X is DOUBLE PRECISION array, dimension (1+(N1)*INCX) On entry, the vector of length n to be sorted. On exit, the vector x is sorted in the prescribed order. 
[in]  INCX  INCX is INTEGER The spacing between successive elements of X. INCX >= 0. 
Definition at line 74 of file dlaord.f.
subroutine dlaptm  (  integer  N, 
integer  NRHS,  
double precision  ALPHA,  
double precision, dimension( * )  D,  
double precision, dimension( * )  E,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision  BETA,  
double precision, dimension( ldb, * )  B,  
integer  LDB  
) 
DLAPTM
DLAPTM multiplies an N by NRHS matrix X by a symmetric 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]  N  N is INTEGER The order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices X and B. 
[in]  ALPHA  ALPHA is DOUBLE PRECISION The scalar alpha. ALPHA must be 1. or 1.; otherwise, it is assumed to be 0. 
[in]  D  D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is DOUBLE PRECISION array, dimension (N1) The (n1) subdiagonal or superdiagonal elements of A. 
[in]  X  X is DOUBLE PRECISION array, dimension (LDX,NRHS) The N by NRHS matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(N,1). 
[in]  BETA  BETA is DOUBLE PRECISION The scalar beta. BETA must be 0., 1., or 1.; otherwise, it is assumed to be 1. 
[in,out]  B  B is DOUBLE PRECISION 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 117 of file dlaptm.f.
subroutine dlarhs  (  character*3  PATH, 
character  XTYPE,  
character  UPLO,  
character  TRANS,  
integer  M,  
integer  N,  
integer  KL,  
integer  KU,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
integer, dimension( 4 )  ISEED,  
integer  INFO  
) 
DLARHS
DLARHS 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 or A' (transpose of A).
[in]  PATH  PATH is CHARACTER*3 The type of the real matrix A. PATH may be given in any combination of upper and lower case. Valid types include xGE: General m x n matrix xGB: General banded matrix xPO: Symmetric positive definite, 2D storage xPP: Symmetric positive definite packed xPB: Symmetric positive definite 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 Specifies whether the upper or lower triangular part of the matrix A is stored, if A is symmetric. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies the operation applied to the matrix A. = 'N': System is A * x = b = 'T': System is A'* x = b = 'C': System is A'* x = b 
[in]  M  M is INTEGER The number or 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 DOUBLE PRECISION 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) DOUBLE PRECISION 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 DOUBLE PRECISION 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 DLATMS). Modified on exit. 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 204 of file dlarhs.f.
subroutine dlatb4  (  character*3  PATH, 
integer  IMAT,  
integer  M,  
integer  N,  
character  TYPE,  
integer  KL,  
integer  KU,  
double precision  ANORM,  
integer  MODE,  
double precision  CNDNUM,  
character  DIST  
) 
DLATB4
DLATB4 sets parameters for the matrix generator based on the type of matrix to be generated.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name. 
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  M  M is INTEGER The number of rows in the matrix to be generated. 
[in]  N  N is INTEGER The number of columns in the matrix to be generated. 
[out]  TYPE  TYPE is CHARACTER*1 The type of the matrix to be generated: = 'S': symmetric matrix = 'P': symmetric positive (semi)definite matrix = 'N': nonsymmetric matrix 
[out]  KL  KL is INTEGER The lower band width of the matrix to be generated. 
[out]  KU  KU is INTEGER The upper band width of the matrix to be generated. 
[out]  ANORM  ANORM is DOUBLE PRECISION The desired norm of the matrix to be generated. The diagonal matrix of singular values or eigenvalues is scaled by this value. 
[out]  MODE  MODE is INTEGER A key indicating how to choose the vector of eigenvalues. 
[out]  CNDNUM  CNDNUM is DOUBLE PRECISION The desired condition number. 
[out]  DIST  DIST is CHARACTER*1 The type of distribution to be used by the random number generator. 
Definition at line 120 of file dlatb4.f.
subroutine dlatb5  (  character*3  PATH, 
integer  IMAT,  
integer  N,  
character  TYPE,  
integer  KL,  
integer  KU,  
double precision  ANORM,  
integer  MODE,  
double precision  CNDNUM,  
character  DIST  
) 
DLATB5
DLATB5 sets parameters for the matrix generator based on the type of matrix to be generated.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name. 
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  N  N is INTEGER The number of rows and columns in the matrix to be generated. 
[out]  TYPE  TYPE is CHARACTER*1 The type of the matrix to be generated: = 'S': symmetric matrix = 'P': symmetric positive (semi)definite matrix = 'N': nonsymmetric matrix 
[out]  KL  KL is INTEGER The lower band width of the matrix to be generated. 
[out]  KU  KU is INTEGER The upper band width of the matrix to be generated. 
[out]  ANORM  ANORM is DOUBLE PRECISION The desired norm of the matrix to be generated. The diagonal matrix of singular values or eigenvalues is scaled by this value. 
[out]  MODE  MODE is INTEGER A key indicating how to choose the vector of eigenvalues. 
[out]  CNDNUM  CNDNUM is DOUBLE PRECISION The desired condition number. 
[out]  DIST  DIST is CHARACTER*1 The type of distribution to be used by the random number generator. 
Definition at line 114 of file dlatb5.f.
subroutine dlattb  (  integer  IMAT, 
character  UPLO,  
character  TRANS,  
character  DIAG,  
integer, dimension( 4 )  ISEED,  
integer  N,  
integer  KD,  
double precision, dimension( ldab, * )  AB,  
integer  LDAB,  
double precision, dimension( * )  B,  
double precision, dimension( * )  WORK,  
integer  INFO  
) 
DLATTB
DLATTB 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 DLATMS). 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (N) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (2*N) 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = k, the kth argument had an illegal value 
Definition at line 135 of file dlattb.f.
subroutine dlattp  (  integer  IMAT, 
character  UPLO,  
character  TRANS,  
character  DIAG,  
integer, dimension( 4 )  ISEED,  
integer  N,  
double precision, dimension( * )  A,  
double precision, dimension( * )  B,  
double precision, dimension( * )  WORK,  
integer  INFO  
) 
DLATTP
DLATTP 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 (= 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 DLATMS). Modified on exit. 
[in]  N  N is INTEGER The order of the matrix to be generated. 
[out]  A  A is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (N) The right hand side vector, if IMAT > 10. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (3*N) 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = k, the kth argument had an illegal value 
Definition at line 125 of file dlattp.f.
subroutine dlattr  (  integer  IMAT, 
character  UPLO,  
character  TRANS,  
character  DIAG,  
integer, dimension( 4 )  ISEED,  
integer  N,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( * )  B,  
double precision, dimension( * )  WORK,  
integer  INFO  
) 
DLATTR
DLATTR generates a triangular test matrix. 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 DLATMS). Modified on exit. 
[in]  N  N is INTEGER The order of the matrix to be generated. 
[out]  A  A is DOUBLE PRECISION array, dimension (LDA,N) The triangular matrix A. If UPLO = 'U', the leading n by n upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading n by n lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If DIAG = 'U', the diagonal elements of A are set so that A(k,k) = k for 1 <= k <= n. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[out]  B  B is DOUBLE PRECISION array, dimension (N) The right hand side vector, if IMAT > 10. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (3*N) 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = k, the kth argument had an illegal value 
Definition at line 133 of file dlattr.f.
subroutine dlavsp  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
double precision, dimension( * )  A,  
integer, dimension( * )  IPIV,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
integer  INFO  
) 
DLAVSP
DLAVSP 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 DSPTRF. 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' ) If TRANS = 'C', 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 = 'C': 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 DOUBLE PRECISION array, dimension (N*(N+1)/2) The block diagonal matrix D and the multipliers used to obtain the factor U or L, stored as a packed triangular matrix as computed by DSPTRF. 
[in]  IPIV  IPIV is INTEGER array, dimension (N) The pivot indices from DSPTRF. 
[in,out]  B  B is DOUBLE PRECISION 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 130 of file dlavsp.f.
subroutine dlavsy  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
integer, dimension( * )  IPIV,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
integer  INFO  
) 
DLAVSY
DLAVSY 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 DSYTRF. 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') If TRANS = 'C', 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 = 'C': 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 DOUBLE PRECISION array, dimension (LDA,N) The block diagonal matrix D and the multipliers used to obtain the factor U or L as computed by DSYTRF. 
[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 DSYTRF. 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 DOUBLE PRECISION 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 154 of file dlavsy.f.
subroutine dlqt01  (  integer  M, 
integer  N,  
double precision, dimension( lda, * )  A,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  Q,  
double precision, dimension( lda, * )  L,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DLQT01
DLQT01 tests DGELQF, which computes the LQ factorization of an mbyn matrix A, and partially tests DORGLQ which forms the nbyn orthogonal matrix Q. DLQT01 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 DOUBLE PRECISION array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is DOUBLE PRECISION array, dimension (LDA,N) Details of the LQ factorization of A, as returned by DGELQF. See DGELQF for further details. 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,N) The nbyn orthogonal matrix Q. 
[out]  L  L is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by DGELQF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(M,N)) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( L  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 126 of file dlqt01.f.
subroutine dlqt02  (  integer  M, 
integer  N,  
integer  K,  
double precision, dimension( lda, * )  A,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  Q,  
double precision, dimension( lda, * )  L,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DLQT02
DLQT02 tests DORGLQ, 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, DLQT02 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 DOUBLE PRECISION array, dimension (LDA,N) The mbyn matrix A which was factorized by DLQT01. 
[in]  AF  AF is DOUBLE PRECISION array, dimension (LDA,N) Details of the LQ factorization of A, as returned by DGELQF. See DGELQF for further details. 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  L  L is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (M) The scalar factors of the elementary reflectors corresponding to the LQ factorization in AF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( L  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 135 of file dlqt02.f.
subroutine dlqt03  (  integer  M, 
integer  N,  
integer  K,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  C,  
double precision, dimension( lda, * )  CC,  
double precision, dimension( lda, * )  Q,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DLQT03
DLQT03 tests DORMLQ, which computes Q*C, Q'*C, C*Q or C*Q'. DLQT03 compares the results of a call to DORMLQ with the results of forming Q explicitly by a call to DORGLQ and then performing matrix multiplication by a call to DGEMM.
[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 DOUBLE PRECISION array, dimension (LDA,N) Details of the LQ factorization of an mbyn matrix, as returned by DGELQF. See SGELQF for further details. 
[out]  C  C is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  CC  CC is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,N) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q. 
[in]  TAU  TAU is DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the LQ factorization in AF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of WORK. LWORK must be at least M, and should be M*NB, where NB is the blocksize for this environment. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an nbyn orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( N * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( N * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( N * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( N * norm(C) * EPS ) 
Definition at line 136 of file dlqt03.f.
subroutine dpbt01  (  character  UPLO, 
integer  N,  
integer  KD,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DPBT01
DPBT01 reconstructs a symmetric 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 symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  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 DOUBLE PRECISION array, dimension (LDA,N) The original symmetric 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 DPBTRF for further details. 
[in]  LDA  LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,KD+1). 
[in]  AFAC  AFAC is DOUBLE PRECISION 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 DPBTRF. 
[in]  LDAFAC  LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,KD+1). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
Definition at line 119 of file dpbt01.f.
subroutine dpbt02  (  character  UPLO, 
integer  N,  
integer  KD,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DPBT02
DPBT02 computes the residual for a solution of a symmetric 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 symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  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 DOUBLE PRECISION array, dimension (LDA,N) The original symmetric 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 DPBTRF for further details. 
[in]  LDA  LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,KD+1). 
[in]  X  X is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 136 of file dpbt02.f.
subroutine dpbt05  (  character  UPLO, 
integer  N,  
integer  KD,  
integer  NRHS,  
double precision, dimension( ldab, * )  AB,  
integer  LDAB,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
double precision, dimension( * )  FERR,  
double precision, dimension( * )  BERR,  
double precision, dimension( * )  RESLTS  
) 
DPBT05
DPBT05 tests the error bounds from iterative refinement for the computed solution to a system of equations A*X = B, where A is a symmetric 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 symmetric 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 DOUBLE PRECISION array, dimension (LDAB,N) The upper or lower triangle of the symmetric 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 171 of file dpbt05.f.
subroutine dpot01  (  character  UPLO, 
integer  N,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DPOT01
DPOT01 reconstructs a symmetric 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.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is DOUBLE PRECISION array, dimension (LDA,N) The original symmetric matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N) 
[in,out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (LDAFAC,N) On entry, the factor L or U from the L*L' or U'*U factorization of A. Overwritten with the reconstructed matrix, and then with the difference L*L'  A (or U'*U  A). 
[in]  LDAFAC  LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
Definition at line 105 of file dpot01.f.
subroutine dpot02  (  character  UPLO, 
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DPOT02
DPOT02 computes the residual for the solution of a symmetric 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 symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is DOUBLE PRECISION array, dimension (LDA,N) The original symmetric matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N) 
[in]  X  X is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 127 of file dpot02.f.
subroutine dpot03  (  character  UPLO, 
integer  N,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldainv, * )  AINV,  
integer  LDAINV,  
double precision, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
double precision, dimension( * )  RWORK,  
double precision  RCOND,  
double precision  RESID  
) 
DPOT03
DPOT03 computes the residual for a symmetric 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 symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is DOUBLE PRECISION array, dimension (LDA,N) The original symmetric matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N) 
[in,out]  AINV  AINV is DOUBLE PRECISION array, dimension (LDAINV,N) On entry, the inverse of the matrix A, stored as a symmetric matrix in the same format as A. In this version, AINV is expanded into a full matrix and multiplied by A, so the opposing triangle of AINV will be changed; i.e., if the upper triangular part of AINV is stored, the lower triangular part will be used as work space. 
[in]  LDAINV  LDAINV is INTEGER The leading dimension of the array AINV. LDAINV >= max(1,N). 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RCOND  RCOND is DOUBLE PRECISION The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is DOUBLE PRECISION norm(I  A*AINV) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 125 of file dpot03.f.
subroutine dpot05  (  character  UPLO, 
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
double precision, dimension( * )  FERR,  
double precision, dimension( * )  BERR,  
double precision, dimension( * )  RESLTS  
) 
DPOT05
DPOT05 tests the error bounds from iterative refinement for the computed solution to a system of equations A*X = B, where A is a symmetric 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 symmetric 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 DOUBLE PRECISION array, dimension (LDA,N) The symmetric 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) ) 
Definition at line 164 of file dpot05.f.
subroutine dpot06  (  character  UPLO, 
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DPOT06
DPOT06 computes the residual for a solution of a system of linear equations A*x = b : RESID = norm(B  A*X,inf) / ( norm(A,inf) * norm(X,inf) * EPS ), where EPS is the machine epsilon.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is DOUBLE PRECISION array, dimension (LDA,N) The original M x N matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[in]  X  X is DOUBLE PRECISION array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,N). 
[in,out]  B  B is DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 127 of file dpot06.f.
subroutine dppt01  (  character  UPLO, 
integer  N,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DPPT01
DPPT01 reconstructs a symmetric 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.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is DOUBLE PRECISION array, dimension (N*(N+1)/2) The original symmetric matrix A, stored as a packed triangular matrix. 
[in,out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (N*(N+1)/2) On entry, the factor L or U from the L*L' or U'*U factorization of A, stored as a packed triangular matrix. Overwritten with the reconstructed matrix, and then with the difference L*L'  A (or U'*U  A). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
Definition at line 94 of file dppt01.f.
subroutine dppt02  (  character  UPLO, 
integer  N,  
integer  NRHS,  
double precision, dimension( * )  A,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DPPT02
DPPT02 computes the residual in the solution of a symmetric system of linear equations A*x = b when packed storage is used for the coefficient matrix. The ratio computed is RESID = norm(B  A*X) / ( norm(A) * norm(X) * EPS), where EPS is the machine precision.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is DOUBLE PRECISION array, dimension (N*(N+1)/2) The original symmetric matrix A, stored as a packed triangular matrix. 
[in]  X  X is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 122 of file dppt02.f.
subroutine dppt03  (  character  UPLO, 
integer  N,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AINV,  
double precision, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
double precision, dimension( * )  RWORK,  
double precision  RCOND,  
double precision  RESID  
) 
DPPT03
DPPT03 computes the residual for a symmetric 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 symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is DOUBLE PRECISION array, dimension (N*(N+1)/2) The original symmetric matrix A, stored as a packed triangular matrix. 
[in]  AINV  AINV is DOUBLE PRECISION array, dimension (N*(N+1)/2) The (symmetric) inverse of the matrix A, stored as a packed triangular matrix. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RCOND  RCOND is DOUBLE PRECISION The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is DOUBLE PRECISION norm(I  A*AINV) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 110 of file dppt03.f.
subroutine dppt05  (  character  UPLO, 
integer  N,  
integer  NRHS,  
double precision, dimension( * )  AP,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
double precision, dimension( * )  FERR,  
double precision, dimension( * )  BERR,  
double precision, dimension( * )  RESLTS  
) 
DPPT05
DPPT05 tests the error bounds from iterative refinement for the computed solution to a system of equations A*X = B, where A is a symmetric 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 symmetric 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 DOUBLE PRECISION array, dimension (N*(N+1)/2) The upper or lower triangle of the symmetric 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) ) 
Definition at line 156 of file dppt05.f.
subroutine dpst01  (  character  UPLO, 
integer  N,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
double precision, dimension( ldperm, * )  PERM,  
integer  LDPERM,  
integer, dimension( * )  PIV,  
double precision, dimension( * )  RWORK,  
double precision  RESID,  
integer  RANK  
) 
DPST01
DPST01 reconstructs a symmetric 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.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is DOUBLE PRECISION array, dimension (LDA,N) The original symmetric matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N) 
[in]  AFAC  AFAC is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDPERM,N) Overwritten with the reconstructed matrix, and then with the difference P*L*L'*P'  A (or P*U'*U*P'  A) 
[in]  LDPERM  LDPERM is INTEGER The leading dimension of the array PERM. LDAPERM >= max(1,N). 
[in]  PIV  PIV is INTEGER array, dimension (N) PIV is such that the nonzero entries are P( PIV( K ), K ) = 1. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
[in]  RANK  RANK is INTEGER number of nonzero singular values of A. 
Definition at line 134 of file dpst01.f.
subroutine dptt01  (  integer  N, 
double precision, dimension( * )  D,  
double precision, dimension( * )  E,  
double precision, dimension( * )  DF,  
double precision, dimension( * )  EF,  
double precision, dimension( * )  WORK,  
double precision  RESID  
) 
DPTT01
DPTT01 reconstructs a tridiagonal matrix A from its L*D*L' factorization and computes the residual norm(L*D*L'  A) / ( n * norm(A) * EPS ), where EPS is the machine epsilon.
[in]  N  N is INTEGTER The order of the matrix A. 
[in]  D  D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is DOUBLE PRECISION array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  DF  DF is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the factor L from the L*D*L' factorization of A. 
[in]  EF  EF is DOUBLE PRECISION array, dimension (N1) The (n1) subdiagonal elements of the factor L from the L*D*L' factorization of A. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (2*N) 
[out]  RESID  RESID is DOUBLE PRECISION norm(L*D*L'  A) / (n * norm(A) * EPS) 
Definition at line 92 of file dptt01.f.
subroutine dptt02  (  integer  N, 
integer  NRHS,  
double precision, dimension( * )  D,  
double precision, dimension( * )  E,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision  RESID  
) 
DPTT02
DPTT02 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]  N  N is INTEGTER The order of the matrix A. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. 
[in]  D  D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is DOUBLE PRECISION array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  X  X is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the n by nrhs matrix of right hand side vectors B. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RESID  RESID is DOUBLE PRECISION norm(B  A*X) / (norm(A) * norm(X) * EPS) 
Definition at line 105 of file dptt02.f.
subroutine dptt05  (  integer  N, 
integer  NRHS,  
double precision, dimension( * )  D,  
double precision, dimension( * )  E,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
double precision, dimension( * )  FERR,  
double precision, dimension( * )  BERR,  
double precision, dimension( * )  RESLTS  
) 
DPTT05
DPTT05 tests the error bounds from iterative refinement for the computed solution to a system of equations A*X = B, where A is a symmetric tridiagonal matrix of order n. RESLTS(1) = test of the error bound = norm(X  XACT) / ( norm(X) * FERR ) A large value is returned if this ratio is not less than one. RESLTS(2) = residual from the iterative refinement routine = the maximum of BERR / ( NZ*EPS + (*) ), where (*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i ) and NZ = max. number of nonzeros in any row of A, plus 1
[in]  N  N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  D  D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is DOUBLE PRECISION array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  B  B is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 150 of file dptt05.f.
subroutine dqlt01  (  integer  M, 
integer  N,  
double precision, dimension( lda, * )  A,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  Q,  
double precision, dimension( lda, * )  L,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DQLT01
DQLT01 tests DGEQLF, which computes the QL factorization of an mbyn matrix A, and partially tests DORGQL which forms the mbym orthogonal matrix Q. DQLT01 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 DOUBLE PRECISION array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is DOUBLE PRECISION array, dimension (LDA,N) Details of the QL factorization of A, as returned by DGEQLF. See DGEQLF for further details. 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  L  L is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by DGEQLF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( L  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 126 of file dqlt01.f.
subroutine dqlt02  (  integer  M, 
integer  N,  
integer  K,  
double precision, dimension( lda, * )  A,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  Q,  
double precision, dimension( lda, * )  L,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DQLT02
DQLT02 tests DORGQL, 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, DQLT02 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 DOUBLE PRECISION array, dimension (LDA,N) The mbyn matrix A which was factorized by DQLT01. 
[in]  AF  AF is DOUBLE PRECISION array, dimension (LDA,N) Details of the QL factorization of A, as returned by DGEQLF. See DGEQLF for further details. 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  L  L is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (N) The scalar factors of the elementary reflectors corresponding to the QL factorization in AF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( L  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 136 of file dqlt02.f.
subroutine dqlt03  (  integer  M, 
integer  N,  
integer  K,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  C,  
double precision, dimension( lda, * )  CC,  
double precision, dimension( lda, * )  Q,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DQLT03
DQLT03 tests DORMQL, which computes Q*C, Q'*C, C*Q or C*Q'. DQLT03 compares the results of a call to DORMQL with the results of forming Q explicitly by a call to DORGQL and then performing matrix multiplication by a call to DGEMM.
[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 DOUBLE PRECISION array, dimension (LDA,N) Details of the QL factorization of an mbyn matrix, as returned by DGEQLF. See SGEQLF for further details. 
[out]  C  C is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  CC  CC is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,M) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q. 
[in]  TAU  TAU is DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the QL factorization in AF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of WORK. LWORK must be at least M, and should be M*NB, where NB is the blocksize for this environment. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an mbym orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( M * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( M * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( M * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( M * norm(C) * EPS ) 
Definition at line 136 of file dqlt03.f.
DOUBLE PRECISION function dqpt01  (  integer  M, 
integer  N,  
integer  K,  
double precision, dimension( lda, * )  A,  
double precision, dimension( lda, * )  AF,  
integer  LDA,  
double precision, dimension( * )  TAU,  
integer, dimension( * )  JPVT,  
double precision, dimension( lwork )  WORK,  
integer  LWORK  
) 
DQPT01
DQPT01 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 DOUBLE PRECISION array, dimension (LDA, N) The original matrix A. 
[in]  AF  AF is DOUBLE PRECISION array, dimension (LDA,N) The (possibly partial) output of DGEQPF. 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 DOUBLE PRECISION array, dimension (K) Details of the Householder transformations as returned by DGEQPF. 
[in]  JPVT  JPVT is INTEGER array, dimension (N) Pivot information as returned by DGEQPF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= M*N+N. 
Definition at line 120 of file dqpt01.f.
subroutine dqrt01  (  integer  M, 
integer  N,  
double precision, dimension( lda, * )  A,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  Q,  
double precision, dimension( lda, * )  R,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DQRT01
DQRT01 tests DGEQRF, which computes the QR factorization of an mbyn matrix A, and partially tests DORGQR which forms the mbym orthogonal matrix Q. DQRT01 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 DOUBLE PRECISION array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is DOUBLE PRECISION array, dimension (LDA,N) Details of the QR factorization of A, as returned by DGEQRF. See DGEQRF for further details. 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  R  R is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by DGEQRF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( R  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 126 of file dqrt01.f.
subroutine dqrt01p  (  integer  M, 
integer  N,  
double precision, dimension( lda, * )  A,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  Q,  
double precision, dimension( lda, * )  R,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DQRT01P
DQRT01P tests DGEQRFP, which computes the QR factorization of an mbyn matrix A, and partially tests DORGQR which forms the mbym orthogonal matrix Q. DQRT01P 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 DOUBLE PRECISION array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is DOUBLE PRECISION array, dimension (LDA,N) Details of the QR factorization of A, as returned by DGEQRFP. See DGEQRFP for further details. 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  R  R is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by DGEQRFP. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( R  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 126 of file dqrt01p.f.
subroutine dqrt02  (  integer  M, 
integer  N,  
integer  K,  
double precision, dimension( lda, * )  A,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  Q,  
double precision, dimension( lda, * )  R,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DQRT02
DQRT02 tests DORGQR, 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, DQRT02 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 DOUBLE PRECISION array, dimension (LDA,N) The mbyn matrix A which was factorized by DQRT01. 
[in]  AF  AF is DOUBLE PRECISION array, dimension (LDA,N) Details of the QR factorization of A, as returned by DGEQRF. See DGEQRF for further details. 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  R  R is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (N) The scalar factors of the elementary reflectors corresponding to the QR factorization in AF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( R  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 135 of file dqrt02.f.
subroutine dqrt03  (  integer  M, 
integer  N,  
integer  K,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  C,  
double precision, dimension( lda, * )  CC,  
double precision, dimension( lda, * )  Q,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DQRT03
DQRT03 tests DORMQR, which computes Q*C, Q'*C, C*Q or C*Q'. DQRT03 compares the results of a call to DORMQR with the results of forming Q explicitly by a call to DORGQR and then performing matrix multiplication by a call to DGEMM.
[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 DOUBLE PRECISION array, dimension (LDA,N) Details of the QR factorization of an mbyn matrix, as returnedby DGEQRF. See SGEQRF for further details. 
[out]  C  C is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  CC  CC is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,M) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q. 
[in]  TAU  TAU is DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the QR factorization in AF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of WORK. LWORK must be at least M, and should be M*NB, where NB is the blocksize for this environment. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an mbym orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( M * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( M * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( M * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( M * norm(C) * EPS ) 
Definition at line 136 of file dqrt03.f.
subroutine dqrt04  (  integer  M, 
integer  N,  
integer  NB,  
double precision, dimension(6)  RESULT  
) 
DQRT04
DQRT04 tests DGEQRT and DGEMQRT.
[in]  M  M is INTEGER Number of rows in test matrix. 
[in]  N  N is INTEGER Number of columns in test matrix. 
[in]  NB  NB is INTEGER Block size of test matrix. NB <= Min(M,N). 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (6) Results of each of the six tests below. RESULT(1) =  A  Q R  RESULT(2) =  I  Q^H Q  RESULT(3) =  Q C  Q C  RESULT(4) =  Q^H C  Q^H C  RESULT(5) =  C Q  C Q  RESULT(6) =  C Q^H  C Q^H  
Definition at line 74 of file dqrt04.f.
subroutine dqrt05  (  integer  M, 
integer  N,  
integer  L,  
integer  NB,  
double precision, dimension(6)  RESULT  
) 
DQRT05
DQRT05 tests DTPQRT and DTPMQRT.
[in]  M  M is INTEGER Number of rows in lower part of the test matrix. 
[in]  N  N is INTEGER Number of columns in test matrix. 
[in]  L  L is INTEGER The number of rows of the upper trapezoidal part the lower test matrix. 0 <= L <= M. 
[in]  NB  NB is INTEGER Block size of test matrix. NB <= N. 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (6) Results of each of the six tests below. RESULT(1) =  A  Q R  RESULT(2) =  I  Q^H Q  RESULT(3) =  Q C  Q C  RESULT(4) =  Q^H C  Q^H C  RESULT(5) =  C Q  C Q  RESULT(6) =  C Q^H  C Q^H  
Definition at line 81 of file dqrt05.f.
DOUBLE PRECISION function dqrt11  (  integer  M, 
integer  K,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK  
) 
DQRT11
DQRT11 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (K) The scaling factors tau for the elementary transformations as computed by the QR factorization routine. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= M*M + M. 
Definition at line 99 of file dqrt11.f.
DOUBLE PRECISION function dqrt12  (  integer  M, 
integer  N,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( * )  S,  
double precision, dimension( lwork )  WORK,  
integer  LWORK  
) 
DQRT12
DQRT12 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 DOUBLE PRECISION array, dimension (LDA,N) The MbyN matrix A. Only the upper trapezoid is referenced. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[in]  S  S is DOUBLE PRECISION array, dimension (min(M,N)) The singular values of the matrix A. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= max(M*N + 4*min(M,N) + max(M,N), M*N+2*MIN( M, N )+4*N). 
Definition at line 90 of file dqrt12.f.
subroutine dqrt13  (  integer  SCALE, 
integer  M,  
integer  N,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision  NORMA,  
integer, dimension( 4 )  ISEED  
) 
DQRT13
DQRT13 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 DOUBLE PRECISION array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[out]  NORMA  NORMA is DOUBLE PRECISION The onenorm of A. 
[in,out]  ISEED  ISEED is integer array, dimension (4) Seed for random number generator 
Definition at line 92 of file dqrt13.f.
DOUBLE PRECISION function dqrt14  (  character  TRANS, 
integer  M,  
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( lwork )  WORK,  
integer  LWORK  
) 
DQRT14
DQRT14 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 = 'T') 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 = 'T': Transpose, check for X in the 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 DOUBLE PRECISION array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[in]  X  X is DOUBLE PRECISION array, dimension (LDX,NRHS) If TRANS = 'N', the NbyNRHS matrix X. IF TRANS = 'T', the MbyNRHS matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. 
[out]  WORK  WORK is DOUBLE PRECISION array dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER length of workspace array required If TRANS = 'N', LWORK >= (M+NRHS)*(N+2); if TRANS = 'T', LWORK >= (N+NRHS)*(M+2). 
Definition at line 116 of file dqrt14.f.
subroutine dqrt15  (  integer  SCALE, 
integer  RKSEL,  
integer  M,  
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( * )  S,  
integer  RANK,  
double precision  NORMA,  
double precision  NORMB,  
integer, dimension( 4 )  ISEED,  
double precision, dimension( lwork )  WORK,  
integer  LWORK  
) 
DQRT15
DQRT15 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 DOUBLE PRECISION array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[out]  B  B is DOUBLE PRECISION array, dimension (LDB, NRHS) A matrix that is in the range space of matrix A. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. 
[out]  S  S is DOUBLE PRECISION array, dimension MIN(M,N) Singular values of A. 
[out]  RANK  RANK is INTEGER number of nonzero singular values of A. 
[out]  NORMA  NORMA is DOUBLE PRECISION onenorm of A. 
[out]  NORMB  NORMB is DOUBLE PRECISION onenorm of B. 
[in,out]  ISEED  ISEED is integer array, dimension (4) seed for random number generator. 
[out]  WORK  WORK is DOUBLE PRECISION 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 148 of file dqrt15.f.
subroutine dqrt16  (  character  TRANS, 
integer  M,  
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DQRT16
DQRT16 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'*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]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( max(m,n) * norm(A) * norm(X) * EPS ). 
Definition at line 133 of file dqrt16.f.
DOUBLE PRECISION function dqrt17  (  character  TRANS, 
integer  IRESID,  
integer  M,  
integer  N,  
integer  NRHS,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( ldb, * )  C,  
double precision, dimension( lwork )  WORK,  
integer  LWORK  
) 
DQRT17
DQRT17 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. = 'T': 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 = 'T', 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 = 'T', 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDX,NRHS) If TRANS = 'N', the nbynrhs matrix X. If TRANS = 'T', the mbynrhs matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= N. If TRANS = 'T', LDX >= M. 
[in]  B  B is DOUBLE PRECISION array, dimension (LDB,NRHS) If TRANS = 'N', the mbynrhs matrix B. If TRANS = 'T', the nbynrhs matrix B. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. If TRANS = 'N', LDB >= M. If TRANS = 'T', LDB >= N. 
[out]  C  C is DOUBLE PRECISION array, dimension (LDB,NRHS) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= NRHS*(M+N). 
Definition at line 150 of file dqrt17.f.
subroutine drqt01  (  integer  M, 
integer  N,  
double precision, dimension( lda, * )  A,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  Q,  
double precision, dimension( lda, * )  R,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DRQT01
DRQT01 tests DGERQF, which computes the RQ factorization of an mbyn matrix A, and partially tests DORGRQ which forms the nbyn orthogonal matrix Q. DRQT01 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 DOUBLE PRECISION array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is DOUBLE PRECISION array, dimension (LDA,N) Details of the RQ factorization of A, as returned by DGERQF. See DGERQF for further details. 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,N) The nbyn orthogonal matrix Q. 
[out]  R  R is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by DGERQF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(M,N)) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( R  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 126 of file drqt01.f.
subroutine drqt02  (  integer  M, 
integer  N,  
integer  K,  
double precision, dimension( lda, * )  A,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  Q,  
double precision, dimension( lda, * )  R,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DRQT02
DRQT02 tests DORGRQ, 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, DRQT02 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 DOUBLE PRECISION array, dimension (LDA,N) The mbyn matrix A which was factorized by DRQT01. 
[in]  AF  AF is DOUBLE PRECISION array, dimension (LDA,N) Details of the RQ factorization of A, as returned by DGERQF. See DGERQF for further details. 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  R  R is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (M) The scalar factors of the elementary reflectors corresponding to the RQ factorization in AF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( R  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 136 of file drqt02.f.
subroutine drqt03  (  integer  M, 
integer  N,  
integer  K,  
double precision, dimension( lda, * )  AF,  
double precision, dimension( lda, * )  C,  
double precision, dimension( lda, * )  CC,  
double precision, dimension( lda, * )  Q,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK,  
double precision, dimension( * )  RWORK,  
double precision, dimension( * )  RESULT  
) 
DRQT03
DRQT03 tests DORMRQ, which computes Q*C, Q'*C, C*Q or C*Q'. DRQT03 compares the results of a call to DORMRQ with the results of forming Q explicitly by a call to DORGRQ and then performing matrix multiplication by a call to DGEMM.
[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 DOUBLE PRECISION array, dimension (LDA,N) Details of the RQ factorization of an mbyn matrix, as returned by DGERQF. See SGERQF for further details. 
[out]  C  C is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  CC  CC is DOUBLE PRECISION array, dimension (LDA,N) 
[out]  Q  Q is DOUBLE PRECISION array, dimension (LDA,N) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q. 
[in]  TAU  TAU is DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the RQ factorization in AF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of WORK. LWORK must be at least M, and should be M*NB, where NB is the blocksize for this environment. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an nbyn orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( N * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( N * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( N * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( N * norm(C) * EPS ) 
Definition at line 136 of file drqt03.f.
DOUBLE PRECISION function drzt01  (  integer  M, 
integer  N,  
double precision, dimension( lda, * )  A,  
double precision, dimension( lda, * )  AF,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK  
) 
DRZT01
DRZT01 returns  A  R*Q  / ( M * eps * A ) for an upper trapezoidal A that was factored with DTZRZF.
[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 DOUBLE PRECISION array, dimension (LDA,N) The original upper trapezoidal M by N matrix A. 
[in]  AF  AF is DOUBLE PRECISION array, dimension (LDA,N) The output of DTZRZF 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 DOUBLE PRECISION array, dimension (M) Details of the Householder transformations as returned by DTZRZF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= m*n + m*nb. 
Definition at line 98 of file drzt01.f.
DOUBLE PRECISION function drzt02  (  integer  M, 
integer  N,  
double precision, dimension( lda, * )  AF,  
integer  LDA,  
double precision, dimension( * )  TAU,  
double precision, dimension( lwork )  WORK,  
integer  LWORK  
) 
DRZT02
DRZT02 returns  I  Q'*Q  / ( M * eps) where the matrix Q is defined by the Householder transformations generated by DTZRZF.
[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 DOUBLE PRECISION array, dimension (LDA,N) The output of DTZRZF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array AF. 
[in]  TAU  TAU is DOUBLE PRECISION array, dimension (M) Details of the Householder transformations as returned by DTZRZF. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER length of WORK array. LWORK >= N*N+N*NB. 
Definition at line 91 of file drzt02.f.
subroutine dspt01  (  character  UPLO, 
integer  N,  
double precision, dimension( * )  A,  
double precision, dimension( * )  AFAC,  
integer, dimension( * )  IPIV,  
double precision, dimension( ldc, * )  C,  
integer  LDC,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DSPT01
DSPT01 reconstructs a symmetric 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 and EPS is the machine epsilon.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is DOUBLE PRECISION array, dimension (N*(N+1)/2) The original symmetric matrix A, stored as a packed triangular matrix. 
[in]  AFAC  AFAC is DOUBLE PRECISION 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 DSPTRF. 
[in]  IPIV  IPIV is INTEGER array, dimension (N) The pivot indices from DSPTRF. 
[out]  C  C is DOUBLE PRECISION array, dimension (LDC,N) 
[in]  LDC  LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*D*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U*D*U'  A) / ( N * norm(A) * EPS ) 
Definition at line 111 of file dspt01.f.
subroutine dsyt01  (  character  UPLO, 
integer  N,  
double precision, dimension( lda, * )  A,  
integer  LDA,  
double precision, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
integer, dimension( * )  IPIV,  
double precision, dimension( ldc, * )  C,  
integer  LDC,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
DSYT01
DSYT01 reconstructs a symmetric indefinite matrix A from its block L*D*L' or U*D*U' factorization and computes the residual norm( C  A ) / ( N * norm(A) * EPS ), where C is the reconstructed matrix and EPS is the machine epsilon.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is DOUBLE PRECISION array, dimension (LDA,N) The original symmetric matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N) 
[in]  AFAC  AFAC is DOUBLE PRECISION 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 DSYTRF. 
[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 DSYTRF. 
[out]  C  C is DOUBLE PRECISION array, dimension (LDC,N) 
[in]  LDC  LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*D*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U*D*U'  A) / ( N * norm(A) * EPS ) 
Definition at line 124 of file dsyt01.f.
subroutine dtbt02  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  KD,  
integer  NRHS,  
double precision, dimension( ldab, * )  AB,  
integer  LDAB,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( * )  WORK,  
double precision  RESID  
) 
DTBT02
DTBT02 computes the residual for the computed solution to a triangular system of linear equations A*x = b or A' *x = b when A is a triangular band matrix. Here A' is the transpose of A and x and b are N by NRHS matrices. The test ratio is the maximum over the number of right hand sides of norm(b  op(A)*x) / ( norm(op(A)) * norm(x) * EPS ), where op(A) denotes A or A' and EPS is the machine epsilon.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the matrix A is upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies the operation applied to A. = 'N': A *x = b (No transpose) = 'T': A'*x = b (Transpose) = 'C': A'*x = b (Conjugate transpose = Transpose) 
[in]  DIAG  DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Nonunit triangular = 'U': Unit triangular 
[in]  N  N is INTEGER The order of the matrix A. N >= 0. 
[in]  KD  KD is INTEGER The number of superdiagonals or subdiagonals of the triangular band matrix A. KD >= 0. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices X and B. NRHS >= 0. 
[in]  AB  AB is DOUBLE PRECISION array, dimension (LDAB,N) The upper or lower triangular 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]  X  X is DOUBLE PRECISION 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]  B  B is DOUBLE PRECISION 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). 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(op(A)*x  b) / ( norm(op(A)) * norm(x) * EPS ). 
Definition at line 154 of file dtbt02.f.
subroutine dtbt03  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  KD,  
integer  NRHS,  
double precision, dimension( ldab, * )  AB,  
integer  LDAB,  
double precision  SCALE,  
double precision, dimension( * )  CNORM,  
double precision  TSCAL,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( * )  WORK,  
double precision  RESID  
) 
DTBT03
DTBT03 computes the residual for the solution to a scaled triangular system of equations A*x = s*b or A'*x = s*b when A is a triangular band matrix. Here A' is the transpose of A, s is a scalar, and x and b are N by NRHS matrices. The test ratio is the maximum over the number of right hand sides of norm(s*b  op(A)*x) / ( norm(op(A)) * norm(x) * EPS ), where op(A) denotes A or A' and EPS is the machine epsilon.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the matrix A is upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies the operation applied to A. = 'N': A *x = b (No transpose) = 'T': A'*x = b (Transpose) = 'C': A'*x = b (Conjugate transpose = Transpose) 
[in]  DIAG  DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Nonunit triangular = 'U': Unit triangular 
[in]  N  N is INTEGER The order of the matrix A. N >= 0. 
[in]  KD  KD is INTEGER The number of superdiagonals or subdiagonals of the triangular band matrix A. KD >= 0. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices X and B. NRHS >= 0. 
[in]  AB  AB is DOUBLE PRECISION array, dimension (LDAB,N) The upper or lower triangular 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]  SCALE  SCALE is DOUBLE PRECISION The scaling factor s used in solving the triangular system. 
[in]  CNORM  CNORM is DOUBLE PRECISION array, dimension (N) The 1norms of the columns of A, not counting the diagonal. 
[in]  TSCAL  TSCAL is DOUBLE PRECISION The scaling factor used in computing the 1norms in CNORM. CNORM actually contains the column norms of TSCAL*A. 
[in]  X  X is DOUBLE PRECISION 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]  B  B is DOUBLE PRECISION 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). 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(op(A)*x  s*b) / ( norm(op(A)) * norm(x) * EPS ). 
Definition at line 174 of file dtbt03.f.
subroutine dtbt05  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  KD,  
integer  NRHS,  
double precision, dimension( ldab, * )  AB,  
integer  LDAB,  
double precision, dimension( ldb, * )  B,  
integer  LDB,  
double precision, dimension( ldx, * )  X,  
integer  LDX,  
double precision, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
double precision, dimension( * )  FERR,  
double precision, dimension( * )  BERR,  
double precision, dimension( * )  RESLTS  
) 
DTBT05
DTBT05 tests the error bounds from iterative refinement for the computed solution to a system of equations A*X = B, where A is a triangular band matrix. RESLTS(1) = test of the error bound = norm(X  XACT) / ( norm(X) * FERR ) A large value is returned if this ratio is not less than one. RESLTS(2) = residual from the iterative refinement routine = the maximum of BERR / ( NZ*EPS + (*) ), where (*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i ) and NZ = max. number of nonzeros in any row of A, plus 1
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the matrix A is upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies the form of the system of equations. = 'N': A * X = B (No transpose) = 'T': A'* X = B (Transpose) = 'C': A'* X = B (Conjugate transpose = Transpose) 
[in]  DIAG  DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Nonunit triangular = 'U': Unit 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 DOUBLE PRECISION array, dimension (LDAB,N) The upper or lower triangular 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). If DIAG = 'U', the diagonal elements of A are not referenced and are assumed to be 1. 
[in]  LDAB  LDAB is INTEGER The leading dimension of the array AB. LDAB >= KD+1. 
[in]  B  B is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 189 of file dtbt05.f.
subroutine dtbt06  (  double precision  RCOND, 
double precision  RCONDC,  
character  UPLO,  
character  DIAG,  
integer  N,  
integer  KD,  
double precision, dimension( ldab, * )  AB,  
integer  LDAB,  
double precision, dimension( * )  WORK,  
double precision  RAT  
) 
DTBT06
DTBT06 computes a test ratio comparing RCOND (the reciprocal condition number of a triangular matrix A) and RCONDC, the estimate computed by DTBCON. Information about the triangular matrix A is used if one estimate is zero and the other is nonzero to decide if underflow in the estimate is justified.
[in]  RCOND  RCOND is DOUBLE PRECISION The estimate of the reciprocal condition number obtained by forming the explicit inverse of the matrix A and computing RCOND = 1/( norm(A) * norm(inv(A)) ). 
[in]  RCONDC  RCONDC is DOUBLE PRECISION The estimate of the reciprocal condition number computed by DTBCON. 
[in]  UPLO  UPLO is CHARACTER Specifies whether the matrix A is upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  DIAG  DIAG is CHARACTER Specifies whether or not the matrix A is unit triangular. = 'N': Nonunit triangular = 'U': Unit triangular 
[in]  N  N is INTEGER The order of the matrix A. N >= 0. 
[in]  KD  KD is INTEGER The number of superdiagonals or subdiagonals of the triangular band matrix A. KD >= 0. 
[in]  AB  AB is DOUBLE PRECISION array, dimension (LDAB,N) The upper or lower triangular 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. 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (N) 
[out]  RAT  RAT is DOUBLE PRECISION The test ratio. If both RCOND and RCONDC are nonzero, RAT = MAX( RCOND, RCONDC )/MIN( RCOND, RCONDC )  1. If RAT = 0, the two estimates are exactly the same. 
Definition at line 125 of file dtbt06.f.
subroutine dtpt01  (  character  UPLO, 
character  DIAG,  
integer  N,  