LAPACK
3.4.2
LAPACK: Linear Algebra PACKage

Functions/Subroutines  
program  schkaa 
SCHKAA  
subroutine  schkeq (THRESH, NOUT) 
SCHKEQ  
subroutine  schkgb (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, A, LA, AFAC, LAFAC, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SCHKGB  
subroutine  schkge (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SCHKGE  
subroutine  schkgt (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SCHKGT  
subroutine  schklq (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT) 
SCHKLQ  
subroutine  schkpb (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SCHKPB  
subroutine  schkpo (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SCHKPO  
subroutine  schkpp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SCHKPP  
subroutine  schkps (DOTYPE, NN, NVAL, NNB, NBVAL, NRANK, RANKVAL, THRESH, TSTERR, NMAX, A, AFAC, PERM, PIV, WORK, RWORK, NOUT) 
SCHKPS  
subroutine  schkpt (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT) 
SCHKPT  
subroutine  schkq3 (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, THRESH, A, COPYA, S, TAU, WORK, IWORK, NOUT) 
SCHKQ3  
subroutine  schkql (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT) 
SCHKQL  
subroutine  schkqp (DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK, IWORK, NOUT) 
SCHKQP  
subroutine  schkqr (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) 
SCHKQR  
subroutine  schkqrt (THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT) 
SCHKQRT  
subroutine  schkqrtp (THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT) 
SCHKQRTP  
program  schkrfp 
SCHKRFP  
subroutine  schkrq (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) 
SCHKRQ  
subroutine  schksp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SCHKSP  
subroutine  schksy (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SCHKSY  
subroutine  schktb (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AB, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SCHKTB  
subroutine  schktp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AP, AINVP, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SCHKTP  
subroutine  schktr (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SCHKTR  
subroutine  schktz (DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK, NOUT) 
SCHKTZ  
subroutine  sdrvgb (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, LA, AFB, LAFB, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
SDRVGB  
subroutine  sdrvge (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
SDRVGE  
subroutine  sdrvgt (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SDRVGT  
subroutine  sdrvls (DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB, NBVAL, NXVAL, THRESH, TSTERR, A, COPYA, B, COPYB, C, S, COPYS, WORK, IWORK, NOUT) 
SDRVLS  
subroutine  sdrvpb (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
SDRVPB  
subroutine  sdrvpo (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
SDRVPO  
subroutine  sdrvpp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
SDRVPP  
subroutine  sdrvpt (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT) 
SDRVPT  
subroutine  sdrvrf1 (NOUT, NN, NVAL, THRESH, A, LDA, ARF, WORK) 
SDRVRF1  
subroutine  sdrvrf2 (NOUT, NN, NVAL, A, LDA, ARF, AP, ASAV) 
SDRVRF2  
subroutine  sdrvrf3 (NOUT, NN, NVAL, THRESH, A, LDA, ARF, B1, B2, S_WORK_SLANGE, S_WORK_SGEQRF, TAU) 
SDRVRF3  
subroutine  sdrvrf4 (NOUT, NN, NVAL, THRESH, C1, C2, LDC, CRF, A, LDA, S_WORK_SLANGE) 
SDRVRF4  
subroutine  sdrvrfp (NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL, THRESH, A, ASAV, AFAC, AINV, B, BSAV, XACT, X, ARF, ARFINV, S_WORK_SLATMS, S_WORK_SPOT01, S_TEMP_SPOT02, S_TEMP_SPOT03, S_WORK_SLANSY, S_WORK_SPOT02, S_WORK_SPOT03) 
SDRVRFP  
subroutine  sdrvsp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SDRVSP  
subroutine  sdrvsy (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
SDRVSY  
subroutine  sebchvxx (THRESH, PATH) 
SEBCHVXX  
subroutine  serrge (PATH, NUNIT) 
SERRGE  
subroutine  serrgt (PATH, NUNIT) 
SERRGT  
subroutine  serrlq (PATH, NUNIT) 
SERRLQ  
subroutine  serrls (PATH, NUNIT) 
SERRLS  
subroutine  serrpo (PATH, NUNIT) 
SERRPO  
subroutine  serrps (PATH, NUNIT) 
SERRPS  
subroutine  serrql (PATH, NUNIT) 
SERRQL  
subroutine  serrqp (PATH, NUNIT) 
SERRQP  
subroutine  serrqr (PATH, NUNIT) 
SERRQR  
subroutine  serrqrt (PATH, NUNIT) 
SERRQRT  
subroutine  serrqrtp (PATH, NUNIT) 
SERRQRTP  
subroutine  serrrfp (NUNIT) 
SERRRFP  
subroutine  serrrq (PATH, NUNIT) 
SERRRQ  
subroutine  serrsy (PATH, NUNIT) 
SERRSY  
subroutine  serrtr (PATH, NUNIT) 
SERRTR  
subroutine  serrtz (PATH, NUNIT) 
SERRTZ  
subroutine  serrvx (PATH, NUNIT) 
SERRVX  
subroutine  sgbt01 (M, N, KL, KU, A, LDA, AFAC, LDAFAC, IPIV, WORK, RESID) 
SGBT01  
subroutine  sgbt02 (TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, RESID) 
SGBT02  
subroutine  sgbt05 (TRANS, N, KL, KU, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
SGBT05  
subroutine  sgelqs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
SGELQS  
LOGICAL function  sgennd (M, N, A, LDA) 
SGENND  
subroutine  sgeqls (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
SGEQLS  
subroutine  sgeqrs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
SGEQRS  
subroutine  sgerqs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
SGERQS  
subroutine  sget01 (M, N, A, LDA, AFAC, LDAFAC, IPIV, RWORK, RESID) 
SGET01  
subroutine  sget02 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
SGET02  
subroutine  sget03 (N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID) 
SGET03  
subroutine  sget04 (N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID) 
SGET04  
REAL function  sget06 (RCOND, RCONDC) 
SGET06  
subroutine  sget07 (TRANS, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, CHKFERR, BERR, RESLTS) 
SGET07  
subroutine  sgtt01 (N, DL, D, DU, DLF, DF, DUF, DU2, IPIV, WORK, LDWORK, RWORK, RESID) 
SGTT01  
subroutine  sgtt02 (TRANS, N, NRHS, DL, D, DU, X, LDX, B, LDB, RESID) 
SGTT02  
subroutine  sgtt05 (TRANS, N, NRHS, DL, D, DU, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
SGTT05  
subroutine  slahilb (N, NRHS, A, LDA, X, LDX, B, LDB, WORK, INFO) 
SLAHILB  
subroutine  slaord (JOB, N, X, INCX) 
SLAORD  
subroutine  slaptm (N, NRHS, ALPHA, D, E, X, LDX, BETA, B, LDB) 
SLAPTM  
subroutine  slarhs (PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO) 
SLARHS  
subroutine  slatb4 (PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST) 
SLATB4  
subroutine  slatb5 (PATH, IMAT, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST) 
SLATB5  
subroutine  slattb (IMAT, UPLO, TRANS, DIAG, ISEED, N, KD, AB, LDAB, B, WORK, INFO) 
SLATTB  
subroutine  slattp (IMAT, UPLO, TRANS, DIAG, ISEED, N, A, B, WORK, INFO) 
SLATTP  
subroutine  slattr (IMAT, UPLO, TRANS, DIAG, ISEED, N, A, LDA, B, WORK, INFO) 
SLATTR  
subroutine  slavsp (UPLO, TRANS, DIAG, N, NRHS, A, IPIV, B, LDB, INFO) 
SLAVSP  
subroutine  slavsy (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO) 
SLAVSY  
subroutine  slqt01 (M, N, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SLQT01  
subroutine  slqt02 (M, N, K, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SLQT02  
subroutine  slqt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SLQT03  
subroutine  spbt01 (UPLO, N, KD, A, LDA, AFAC, LDAFAC, RWORK, RESID) 
SPBT01  
subroutine  spbt02 (UPLO, N, KD, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
SPBT02  
subroutine  spbt05 (UPLO, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
SPBT05  
subroutine  spot01 (UPLO, N, A, LDA, AFAC, LDAFAC, RWORK, RESID) 
SPOT01  
subroutine  spot02 (UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
SPOT02  
subroutine  spot03 (UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID) 
SPOT03  
subroutine  spot05 (UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
SPOT05  
subroutine  sppt01 (UPLO, N, A, AFAC, RWORK, RESID) 
SPPT01  
subroutine  sppt02 (UPLO, N, NRHS, A, X, LDX, B, LDB, RWORK, RESID) 
SPPT02  
subroutine  sppt03 (UPLO, N, A, AINV, WORK, LDWORK, RWORK, RCOND, RESID) 
SPPT03  
subroutine  sppt05 (UPLO, N, NRHS, AP, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
SPPT05  
subroutine  spst01 (UPLO, N, A, LDA, AFAC, LDAFAC, PERM, LDPERM, PIV, RWORK, RESID, RANK) 
SPST01  
subroutine  sptt01 (N, D, E, DF, EF, WORK, RESID) 
SPTT01  
subroutine  sptt02 (N, NRHS, D, E, X, LDX, B, LDB, RESID) 
SPTT02  
subroutine  sptt05 (N, NRHS, D, E, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
SPTT05  
subroutine  sqlt01 (M, N, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SQLT01  
subroutine  sqlt02 (M, N, K, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SQLT02  
subroutine  sqlt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SQLT03  
REAL function  sqpt01 (M, N, K, A, AF, LDA, TAU, JPVT, WORK, LWORK) 
SQPT01  
subroutine  sqrt01 (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SQRT01  
subroutine  sqrt01p (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SQRT01P  
subroutine  sqrt02 (M, N, K, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SQRT02  
subroutine  sqrt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SQRT03  
subroutine  sqrt04 (M, N, NB, RESULT) 
SQRT04  
subroutine  sqrt05 (M, N, L, NB, RESULT) 
SQRT05  
REAL function  sqrt11 (M, K, A, LDA, TAU, WORK, LWORK) 
SQRT11  
REAL function  sqrt12 (M, N, A, LDA, S, WORK, LWORK) 
SQRT12  
subroutine  sqrt13 (SCALE, M, N, A, LDA, NORMA, ISEED) 
SQRT13  
REAL function  sqrt14 (TRANS, M, N, NRHS, A, LDA, X, LDX, WORK, LWORK) 
SQRT14  
subroutine  sqrt15 (SCALE, RKSEL, M, N, NRHS, A, LDA, B, LDB, S, RANK, NORMA, NORMB, ISEED, WORK, LWORK) 
SQRT15  
subroutine  sqrt16 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
SQRT16  
REAL function  sqrt17 (TRANS, IRESID, M, N, NRHS, A, LDA, X, LDX, B, LDB, C, WORK, LWORK) 
SQRT17  
subroutine  srqt01 (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SRQT01  
subroutine  srqt02 (M, N, K, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SRQT02  
subroutine  srqt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
SRQT03  
REAL function  srzt01 (M, N, A, AF, LDA, TAU, WORK, LWORK) 
SRZT01  
REAL function  srzt02 (M, N, AF, LDA, TAU, WORK, LWORK) 
SRZT02  
subroutine  sspt01 (UPLO, N, A, AFAC, IPIV, C, LDC, RWORK, RESID) 
SSPT01  
subroutine  ssyt01 (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID) 
SSYT01  
subroutine  stbt02 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, X, LDX, B, LDB, WORK, RESID) 
STBT02  
subroutine  stbt03 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, SCALE, CNORM, TSCAL, X, LDX, B, LDB, WORK, RESID) 
STBT03  
subroutine  stbt05 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
STBT05  
subroutine  stbt06 (RCOND, RCONDC, UPLO, DIAG, N, KD, AB, LDAB, WORK, RAT) 
STBT06  
subroutine  stpt01 (UPLO, DIAG, N, AP, AINVP, RCOND, WORK, RESID) 
STPT01  
subroutine  stpt02 (UPLO, TRANS, DIAG, N, NRHS, AP, X, LDX, B, LDB, WORK, RESID) 
STPT02  
subroutine  stpt03 (UPLO, TRANS, DIAG, N, NRHS, AP, SCALE, CNORM, TSCAL, X, LDX, B, LDB, WORK, RESID) 
STPT03  
subroutine  stpt05 (UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
STPT05  
subroutine  stpt06 (RCOND, RCONDC, UPLO, DIAG, N, AP, WORK, RAT) 
STPT06  
subroutine  strt01 (UPLO, DIAG, N, A, LDA, AINV, LDAINV, RCOND, WORK, RESID) 
STRT01  
subroutine  strt02 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, X, LDX, B, LDB, WORK, RESID) 
STRT02  
subroutine  strt03 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, SCALE, CNORM, TSCAL, X, LDX, B, LDB, WORK, RESID) 
STRT03  
subroutine  strt05 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
STRT05  
subroutine  strt06 (RCOND, RCONDC, UPLO, DIAG, N, A, LDA, WORK, RAT) 
STRT06  
REAL function  stzt01 (M, N, A, AF, LDA, TAU, WORK, LWORK) 
STZT01  
REAL function  stzt02 (M, N, AF, LDA, TAU, WORK, LWORK) 
STZT02 
This is the group of real LAPACK TESTING LIN routines.
program schkaa  (  ) 
SCHKAA
SCHKAA is the main test program for the REAL 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 REAL 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 SGE 11 List types on next line if 0 < NTYPES < 11 SGB 8 List types on next line if 0 < NTYPES < 8 SGT 12 List types on next line if 0 < NTYPES < 12 SPO 9 List types on next line if 0 < NTYPES < 9 SPS 9 List types on next line if 0 < NTYPES < 9 SPP 9 List types on next line if 0 < NTYPES < 9 SPB 8 List types on next line if 0 < NTYPES < 8 SPT 12 List types on next line if 0 < NTYPES < 12 SSY 10 List types on next line if 0 < NTYPES < 10 SSR 10 List types on next line if 0 < NTYPES < 10 SSP 10 List types on next line if 0 < NTYPES < 10 STR 18 List types on next line if 0 < NTYPES < 18 STP 18 List types on next line if 0 < NTYPES < 18 STB 17 List types on next line if 0 < NTYPES < 17 SQR 8 List types on next line if 0 < NTYPES < 8 SRQ 8 List types on next line if 0 < NTYPES < 8 SLQ 8 List types on next line if 0 < NTYPES < 8 SQL 8 List types on next line if 0 < NTYPES < 8 SQP 6 List types on next line if 0 < NTYPES < 6 STZ 3 List types on next line if 0 < NTYPES < 3 SLS 6 List types on next line if 0 < NTYPES < 6 SEQ SQT SQX
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 schkaa.f.
subroutine schkeq  (  real  THRESH, 
integer  NOUT  
) 
SCHKEQ
SCHKEQ tests SGEEQU, SGBEQU, SPOEQU, SPPEQU and SPBEQU
[in]  THRESH  THRESH is REAL Threshold for testing routines. Should be between 2 and 10. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 55 of file schkeq.f.
subroutine schkgb  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
real, dimension( * )  A,  
integer  LA,  
real, dimension( * )  AFAC,  
integer  LAFAC,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKGB
SCHKGB tests SGBTRF, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is REAL 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 REAL 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 REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX,NMAX)) 
[out]  RWORK  RWORK is REAL 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 schkgb.f.
subroutine schkge  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  AINV,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKGE
SCHKGE tests SGETRF, TRI, TRS, RFS, and CON.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(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 schkge.f.
subroutine schkgt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
real, dimension( * )  A,  
real, dimension( * )  AF,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKGT
SCHKGT tests SGTTRF, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is REAL array, dimension (NMAX*4) 
[out]  AF  AF is REAL array, dimension (NMAX*4) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[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 schkgt.f.
subroutine schklq  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AF,  
real, dimension( * )  AQ,  
real, dimension( * )  AL,  
real, dimension( * )  AC,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  TAU,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
SCHKLQ
SCHKLQ tests SGELQF, SORGLQ and SORMLQ.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AF  AF is REAL array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is REAL array, dimension (NMAX*NMAX) 
[out]  AL  AL is REAL array, dimension (NMAX*NMAX) 
[out]  AC  AC is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is REAL array, dimension (NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 195 of file schklq.f.
subroutine schkpb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  AINV,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKPB
SCHKPB tests SPBTRF, TRS, RFS, and CON.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 171 of file schkpb.f.
subroutine schkpo  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  AINV,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKPO
SCHKPO tests SPOTRF, TRI, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 171 of file schkpo.f.
subroutine schkpp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  AINV,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKPP
SCHKPP tests SPPTRF, TRI, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 162 of file schkpp.f.
subroutine schkps  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NRANK,  
integer, dimension( * )  RANKVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  PERM,  
integer, dimension( * )  PIV,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
SCHKPS
SCHKPS tests SPSTRF.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the block size NB. 
[in]  NRANK  NRANK is INTEGER The number of values of RANK contained in the vector RANKVAL. 
[in]  RANKVAL  RANKVAL is INTEGER array, dimension (NBVAL) The values of the block size NB. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  PERM  PERM is REAL array, dimension (NMAX*NMAX) 
[out]  PIV  PIV is INTEGER array, dimension (NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*3) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 153 of file schkps.f.
subroutine schkpt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
real, dimension( * )  A,  
real, dimension( * )  D,  
real, dimension( * )  E,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
SCHKPT
SCHKPT tests SPTTRF, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is REAL array, dimension (NMAX*2) 
[out]  D  D is REAL array, dimension (NMAX*2) 
[out]  E  E is REAL array, dimension (NMAX*2) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 146 of file schkpt.f.
subroutine schkq3  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
real  THRESH,  
real, dimension( * )  A,  
real, dimension( * )  COPYA,  
real, dimension( * )  S,  
real, dimension( * )  TAU,  
real, dimension( * )  WORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKQ3
SCHKQ3 tests SGEQP3.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[out]  A  A is REAL 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 REAL array, dimension (MMAX*NMAX) 
[out]  S  S is REAL array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is REAL array, dimension (MMAX) 
[out]  WORK  WORK is REAL 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 schkq3.f.
subroutine schkql  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AF,  
real, dimension( * )  AQ,  
real, dimension( * )  AL,  
real, dimension( * )  AC,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  TAU,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
SCHKQL
SCHKQL tests SGEQLF, SORGQL and SORMQL.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AF  AF is REAL array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is REAL array, dimension (NMAX*NMAX) 
[out]  AL  AL is REAL array, dimension (NMAX*NMAX) 
[out]  AC  AC is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is REAL array, dimension (NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 195 of file schkql.f.
subroutine schkqp  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
real  THRESH,  
logical  TSTERR,  
real, dimension( * )  A,  
real, dimension( * )  COPYA,  
real, dimension( * )  S,  
real, dimension( * )  TAU,  
real, dimension( * )  WORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKQP
SCHKQP tests SGEQPF.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is REAL 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 REAL array, dimension (MMAX*NMAX) 
[out]  S  S is REAL array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is REAL array, dimension (MMAX) 
[out]  WORK  WORK is REAL 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 schkqp.f.
subroutine schkqr  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AF,  
real, dimension( * )  AQ,  
real, dimension( * )  AR,  
real, dimension( * )  AC,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  TAU,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKQR
SCHKQR tests SGEQRF, SORGQR and SORMQR.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AF  AF is REAL array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is REAL array, dimension (NMAX*NMAX) 
[out]  AR  AR is REAL array, dimension (NMAX*NMAX) 
[out]  AC  AC is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is REAL array, dimension (NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 200 of file schkqr.f.
subroutine schkqrt  (  real  THRESH, 
logical  TSTERR,  
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NOUT  
) 
SCHKQRT
SCHKQRT tests SGEQRT and SGEMQRT.
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 100 of file schkqrt.f.
subroutine schkqrtp  (  real  THRESH, 
logical  TSTERR,  
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NOUT  
) 
SCHKQRTP
SCHKQRTP tests STPQRT and STPMQRT.
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 102 of file schkqrtp.f.
program schkrfp  (  ) 
SCHKRFP
SCHKRFP is the main test program for the REAL 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 schkrfp.f.
subroutine schkrq  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AF,  
real, dimension( * )  AQ,  
real, dimension( * )  AR,  
real, dimension( * )  AC,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  TAU,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKRQ
SCHKRQ tests SGERQF, SORGRQ and SORMRQ.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AF  AF is REAL array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is REAL array, dimension (NMAX*NMAX) 
[out]  AR  AR is REAL array, dimension (NMAX*NMAX) 
[out]  AC  AC is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is REAL array, dimension (NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 200 of file schkrq.f.
subroutine schksp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  AINV,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKSP
SCHKSP tests SSPTRF, TRI, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(2,NSMAX)) 
[out]  RWORK  RWORK is REAL 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 schksp.f.
subroutine schksy  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  AINV,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKSY
SCHKSY tests SSYTRF, TRI2, TRS, TRS2, RFS, and CON.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[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 schksy.f.
subroutine schktb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  AB,  
real, dimension( * )  AINV,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKTB
SCHKTB tests STBTRS, RFS, and CON, and SLATBS.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximum value of N in NVAL. 
[out]  AB  AB is REAL array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 154 of file schktb.f.
subroutine schktp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  AP,  
real, dimension( * )  AINVP,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKTP
SCHKTP tests STPTRI, TRS, RFS, and CON, and SLATPS
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximumm value of N in NVAL. 
[out]  AP  AP is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINVP  AINVP is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 156 of file schktp.f.
subroutine schktr  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AINV,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SCHKTR
SCHKTR tests STRTRI, TRS, RFS, and CON, and SLATRS
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximum value of N in NVAL. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 166 of file schktr.f.
subroutine schktz  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
real  THRESH,  
logical  TSTERR,  
real, dimension( * )  A,  
real, dimension( * )  COPYA,  
real, dimension( * )  S,  
real, dimension( * )  TAU,  
real, dimension( * )  WORK,  
integer  NOUT  
) 
SCHKTZ
SCHKTZ tests STZRQF 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 REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is REAL 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 REAL array, dimension (MMAX*NMAX) 
[out]  S  S is REAL array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is REAL array, dimension (MMAX) 
[out]  WORK  WORK is REAL array, dimension (MMAX*NMAX + 4*NMAX + MMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 132 of file schktz.f.
subroutine sdrvgb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
real, dimension( * )  A,  
integer  LA,  
real, dimension( * )  AFB,  
integer  LAFB,  
real, dimension( * )  ASAV,  
real, dimension( * )  B,  
real, dimension( * )  BSAV,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  S,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SDRVGB
SDRVGBX
SDRVGB tests the driver routines SGBSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is REAL 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 REAL 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 REAL array, dimension (LA) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (2*NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NRHS,NMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NRHS)) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
SDRVGB tests the driver routines SGBSV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise sdrvgb.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is REAL 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 REAL 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 REAL array, dimension (LA) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (2*NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NRHS,NMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NRHS)) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 171 of file sdrvgb.f.
subroutine sdrvge  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  ASAV,  
real, dimension( * )  B,  
real, dimension( * )  BSAV,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  S,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SDRVGE
SDRVGEX
SDRVGE tests the driver routines SGESV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (2*NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (2*NRHS+NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
SDRVGE tests the driver routines SGESV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise sdrvge.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (2*NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL 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 sdrvge.f.
subroutine sdrvgt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
real, dimension( * )  A,  
real, dimension( * )  AF,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SDRVGT
SDRVGT tests SGTSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, NRHS >= 0. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is REAL array, dimension (NMAX*4) 
[out]  AF  AF is REAL array, dimension (NMAX*4) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL 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 sdrvgt.f.
subroutine sdrvls  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
real  THRESH,  
logical  TSTERR,  
real, dimension( * )  A,  
real, dimension( * )  COPYA,  
real, dimension( * )  B,  
real, dimension( * )  COPYB,  
real, dimension( * )  C,  
real, dimension( * )  S,  
real, dimension( * )  COPYS,  
real, dimension( * )  WORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SDRVLS
SDRVLS tests the least squares driver routines SGELS, SGELSS, SGELSX, SGELSY and SGELSD.
[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 REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is REAL 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 REAL array, dimension (MMAX*NMAX) 
[out]  B  B is REAL 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 REAL array, dimension (MMAX*NSMAX) 
[out]  C  C is REAL array, dimension (MMAX*NSMAX) 
[out]  S  S is REAL array, dimension (min(MMAX,NMAX)) 
[out]  COPYS  COPYS is REAL array, dimension (min(MMAX,NMAX)) 
[out]  WORK  WORK is REAL 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 sdrvls.f.
subroutine sdrvpb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  ASAV,  
real, dimension( * )  B,  
real, dimension( * )  BSAV,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  S,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SDRVPB
SDRVPB tests the driver routines SPBSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 163 of file sdrvpb.f.
subroutine sdrvpo  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  ASAV,  
real, dimension( * )  B,  
real, dimension( * )  BSAV,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  S,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SDRVPO
SDRVPOX
SDRVPO tests the driver routines SPOSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
SDRVPO tests the driver routines SPOSV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise sdrvpo.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 163 of file sdrvpo.f.
subroutine sdrvpp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  ASAV,  
real, dimension( * )  B,  
real, dimension( * )  BSAV,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  S,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SDRVPP
SDRVPP tests the driver routines SPPSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  ASAV  ASAV is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (NMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 166 of file sdrvpp.f.
subroutine sdrvpt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
real, dimension( * )  A,  
real, dimension( * )  D,  
real, dimension( * )  E,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
SDRVPT
SDRVPT tests SPTSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is REAL array, dimension (NMAX*2) 
[out]  D  D is REAL array, dimension (NMAX*2) 
[out]  E  E is REAL array, dimension (NMAX*2) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NRHS)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 140 of file sdrvpt.f.
subroutine sdrvrf1  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
real  THRESH,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  ARF,  
real, dimension( * )  WORK  
) 
SDRVRF1
SDRVRF1 tests the LAPACK RFP routines: SLANSF
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[out]  A  A is REAL array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  ARF  ARF is REAL array, dimension ((NMAX*(NMAX+1))/2). 
[out]  WORK  WORK is REAL array, dimension ( NMAX ) 
Definition at line 95 of file sdrvrf1.f.
subroutine sdrvrf2  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  ARF,  
real, dimension(*)  AP,  
real, dimension( lda, * )  ASAV  
) 
SDRVRF2
SDRVRF2 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 REAL array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  ARF  ARF is REAL array, dimension ((NMAX*(NMAX+1))/2). 
[out]  AP  AP is REAL array, dimension ((NMAX*(NMAX+1))/2). 
[out]  ASAV  ASAV is REAL array, dimension (LDA,NMAX) 
Definition at line 90 of file sdrvrf2.f.
subroutine sdrvrf3  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
real  THRESH,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  ARF,  
real, dimension( lda, * )  B1,  
real, dimension( lda, * )  B2,  
real, dimension( * )  S_WORK_SLANGE,  
real, dimension( * )  S_WORK_SGEQRF,  
real, dimension( * )  TAU  
) 
SDRVRF3
SDRVRF3 tests the LAPACK RFP routines: STFSM
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[out]  A  A is REAL array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  ARF  ARF is REAL array, dimension ((NMAX*(NMAX+1))/2). 
[out]  B1  B1 is REAL array, dimension (LDA,NMAX) 
[out]  B2  B2 is REAL array, dimension (LDA,NMAX) 
[out]  S_WORK_SLANGE  S_WORK_SLANGE is REAL array, dimension (NMAX) 
[out]  S_WORK_SGEQRF  S_WORK_SGEQRF is REAL array, dimension (NMAX) 
[out]  TAU  TAU is REAL array, dimension (NMAX) 
Definition at line 118 of file sdrvrf3.f.
subroutine sdrvrf4  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
real  THRESH,  
real, dimension( ldc, * )  C1,  
real, dimension( ldc, *)  C2,  
integer  LDC,  
real, dimension( * )  CRF,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  S_WORK_SLANGE  
) 
SDRVRF4
SDRVRF4 tests the LAPACK RFP routines: SSFRK
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[out]  C1  C1 is REAL array, dimension (LDC,NMAX) 
[out]  C2  C2 is REAL array, dimension (LDC,NMAX) 
[in]  LDC  LDC is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  CRF  CRF is REAL array, dimension ((NMAX*(NMAX+1))/2). 
[out]  A  A is REAL array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  S_WORK_SLANGE  S_WORK_SLANGE is REAL array, dimension (NMAX) 
Definition at line 118 of file sdrvrf4.f.
subroutine sdrvrfp  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
integer  NNS,  
integer, dimension( nns )  NSVAL,  
integer  NNT,  
integer, dimension( nnt )  NTVAL,  
real  THRESH,  
real, dimension( * )  A,  
real, dimension( * )  ASAV,  
real, dimension( * )  AFAC,  
real, dimension( * )  AINV,  
real, dimension( * )  B,  
real, dimension( * )  BSAV,  
real, dimension( * )  XACT,  
real, dimension( * )  X,  
real, dimension( * )  ARF,  
real, dimension( * )  ARFINV,  
real, dimension( * )  S_WORK_SLATMS,  
real, dimension( * )  S_WORK_SPOT01,  
real, dimension( * )  S_TEMP_SPOT02,  
real, dimension( * )  S_TEMP_SPOT03,  
real, dimension( * )  S_WORK_SLANSY,  
real, dimension( * )  S_WORK_SPOT02,  
real, dimension( * )  S_WORK_SPOT03  
) 
SDRVRFP
SDRVRFP tests the LAPACK RFP routines: SPFTRF, SPFTRS, and SPFTRI. 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 STRTTF and STFTTR. 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 SPFTRF, no test ratios are computed) A solution XACT of size NbyNRHS is created and the associated right hand side B as well. Then SPFTRF is called to compute L (or U), the Cholesky factor of A. Then L (or U) is used to solve the linear system of equations AX = B. This gives X. Then L (or U) is used to compute the inverse of A, AINV. The following four tests are then performed: (1) norm( L*L'  A ) / ( N * norm(A) * EPS ) or norm( U'*U  A ) / ( N * norm(A) * EPS ), (2) norm(B  A*X) / ( norm(A) * norm(X) * EPS ), (3) norm( I  A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ), (4) ( norm(XXACT) * RCOND ) / ( norm(XACT) * EPS ), where EPS is the machine precision, RCOND the condition number of A, and norm( . ) the 1norm for (1,2,3) and the infnorm for (4). Errors occur when INFO parameter is not as expected. Failures occur when a test ratios is greater than THRES.
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of righthand sides NRHS. 
[in]  NNT  NNT is INTEGER The number of values of MATRIX TYPE contained in the vector NTVAL. 
[in]  NTVAL  NTVAL is INTEGER array, dimension (NNT) The values of matrix type (between 0 and 9 for PO/PP/PF matrices). 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*MAXRHS) 
[out]  BSAV  BSAV is REAL array, dimension (NMAX*MAXRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*MAXRHS) 
[out]  X  X is REAL array, dimension (NMAX*MAXRHS) 
[out]  ARF  ARF is REAL array, dimension ((NMAX*(NMAX+1))/2) 
[out]  ARFINV  ARFINV is REAL array, dimension ((NMAX*(NMAX+1))/2) 
[out]  S_WORK_SLATMS  S_WORK_SLATMS is REAL array, dimension ( 3*NMAX ) 
[out]  S_WORK_SPOT01  S_WORK_SPOT01 is REAL array, dimension ( NMAX ) 
[out]  S_TEMP_SPOT02  S_TEMP_SPOT02 is REAL array, dimension ( NMAX*MAXRHS ) 
[out]  S_TEMP_SPOT03  S_TEMP_SPOT03 is REAL array, dimension ( NMAX*NMAX ) 
[out]  S_WORK_SLATMS  S_WORK_SLATMS is REAL array, dimension ( NMAX ) 
[out]  S_WORK_SLANSY  S_WORK_SLANSY is REAL array, dimension ( NMAX ) 
[out]  S_WORK_SPOT02  S_WORK_SPOT02 is REAL array, dimension ( NMAX ) 
[out]  S_WORK_SPOT03  S_WORK_SPOT03 is REAL array, dimension ( NMAX ) 
Definition at line 239 of file sdrvrfp.f.
subroutine sdrvsp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  AINV,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SDRVSP
SDRVSP tests the driver routines SSPSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is REAL array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 155 of file sdrvsp.f.
subroutine sdrvsy  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  AINV,  
real, dimension( * )  B,  
real, dimension( * )  X,  
real, dimension( * )  XACT,  
real, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
SDRVSY
SDRVSYX
SDRVSY tests the driver routines SSYSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
SDRVSY tests the driver routines SSYSV, SVX, and SVXX Note that this file is used only when the XBLAS are available, otherwise sdrvsy.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NRHS) 
[out]  X  X is REAL array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 152 of file sdrvsy.f.
subroutine sebchvxx  (  real  THRESH, 
character*3  PATH  
) 
SEBCHVXX
SEBCHVXX will run S**SVXX on a series of Hilbert matrices and then compare the error bounds returned by SGESVXX 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, SGESVXX 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 SGESVXX. Let RCONDc be the RCOND returned by SGESVXX 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 )). 7. 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 sebchvxx.f.
subroutine serrge  (  character*3  PATH, 
integer  NUNIT  
) 
SERRGE
SERRGEX
SERRGE tests the error exits for the REAL 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. 
SERRGE tests the error exits for the REAL routines for general matrices. Note that this file is used only when the XBLAS are available, otherwise serrge.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 serrge.f.
subroutine serrgt  (  character*3  PATH, 
integer  NUNIT  
) 
SERRGT
SERRGT tests the error exits for the REAL 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 serrgt.f.
subroutine serrlq  (  character*3  PATH, 
integer  NUNIT  
) 
SERRLQ
SERRLQ tests the error exits for the REAL 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 serrlq.f.
subroutine serrls  (  character*3  PATH, 
integer  NUNIT  
) 
SERRLS
SERRLS tests the error exits for the REAL least squares driver routines (SGELS, 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 serrls.f.
subroutine serrpo  (  character*3  PATH, 
integer  NUNIT  
) 
SERRPO
SERRPOX
SERRPO tests the error exits for the REAL 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. 
SERRPO tests the error exits for the REAL routines for symmetric positive definite matrices. Note that this file is used only when the XBLAS are available, otherwise serrpo.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 serrpo.f.
subroutine serrps  (  character*3  PATH, 
integer  NUNIT  
) 
SERRPS
SERRPS tests the error exits for the REAL routines for SPSTRF..
[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 serrps.f.
subroutine serrql  (  character*3  PATH, 
integer  NUNIT  
) 
SERRQL
SERRQL tests the error exits for the REAL 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 serrql.f.
subroutine serrqp  (  character*3  PATH, 
integer  NUNIT  
) 
SERRQP
SERRQP tests the error exits for SGEQPF and SGEQP3.
[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 serrqp.f.
subroutine serrqr  (  character*3  PATH, 
integer  NUNIT  
) 
SERRQR
SERRQR tests the error exits for the REAL 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 serrqr.f.
subroutine serrqrt  (  character*3  PATH, 
integer  NUNIT  
) 
SERRQRT
SERRQRT tests the error exits for the REAL 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 serrqrt.f.
subroutine serrqrtp  (  character*3  PATH, 
integer  NUNIT  
) 
SERRQRTP
SERRQRTP 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 serrqrtp.f.
subroutine serrrfp  (  integer  NUNIT  ) 
SERRRFP
SERRRFP tests the error exits for the REAL driver routines for solving linear systems of equations. SDRVRFP tests the REAL LAPACK RFP routines: STFSM, STFTRI, SSFRK, STFTTP, STFTTR, SPFTRF, SPFTRS, STPTTF, STPTTR, STRTTF, and STRTTP
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 53 of file serrrfp.f.
subroutine serrrq  (  character*3  PATH, 
integer  NUNIT  
) 
SERRRQ
SERRRQ tests the error exits for the REAL 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 serrrq.f.
subroutine serrsy  (  character*3  PATH, 
integer  NUNIT  
) 
SERRSY
SERRSYX
SERRSY tests the error exits for the REAL 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. 
SERRSY tests the error exits for the REAL routines for symmetric indefinite matrices. Note that this file is used only when the XBLAS are available, otherwise serrsy.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 serrsy.f.
subroutine serrtr  (  character*3  PATH, 
integer  NUNIT  
) 
SERRTR
SERRTR tests the error exits for the REAL 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 serrtr.f.
subroutine serrtz  (  character*3  PATH, 
integer  NUNIT  
) 
SERRTZ
SERRTZ tests the error exits for STZRQF 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 serrtz.f.
subroutine serrvx  (  character*3  PATH, 
integer  NUNIT  
) 
SERRVX
SERRVXX
SERRVX tests the error exits for the REAL 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. 
SERRVX tests the error exits for the REAL 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 serrvx.f.
subroutine sgbt01  (  integer  M, 
integer  N,  
integer  KL,  
integer  KU,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
integer, dimension( * )  IPIV,  
real, dimension( * )  WORK,  
real  RESID  
) 
SGBT01
SGBT01 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 REAL 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 REAL 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 SGBTRF. 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 SGBTRF 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 SGBTRF. 
[out]  WORK  WORK is REAL array, dimension (2*KL+KU+1) 
[out]  RESID  RESID is REAL norm(L*U  A) / ( N * norm(A) * EPS ) 
Definition at line 126 of file sgbt01.f.
subroutine sgbt02  (  character  TRANS, 
integer  M,  
integer  N,  
integer  KL,  
integer  KU,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real  RESID  
) 
SGBT02
SGBT02 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 REAL 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 REAL 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 REAL array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N). 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 139 of file sgbt02.f.
subroutine sgbt05  (  character  TRANS, 
integer  N,  
integer  KL,  
integer  KU,  
integer  NRHS,  
real, dimension( ldab, * )  AB,  
integer  LDAB,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
SGBT05
SGBT05 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 REAL 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 REAL 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 REAL 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 REAL array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is REAL array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is REAL array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 176 of file sgbt05.f.
subroutine sgelqs  (  integer  M, 
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
SGELQS
Compute a minimumnorm solution min  A*X  B  using the LQ factorization A = L*Q computed by SGELQF.
[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 REAL array, dimension (LDA,N) Details of the LQ factorization of the original matrix A as returned by SGELQF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is REAL array, dimension (M) Details of the orthogonal matrix Q. 
[in,out]  B  B is REAL 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 REAL 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 sgelqs.f.
LOGICAL function sgennd  (  integer  M, 
integer  N,  
real, dimension( lda, * )  A,  
integer  LDA  
) 
SGENND
SGENND 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 REAL array, dimension (LDA, N) The matrix. 
[in]  LDA  LDA is INTEGER Leading dimension of A. 
Definition at line 69 of file sgennd.f.
subroutine sgeqls  (  integer  M, 
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
SGEQLS
Solve the least squares problem min  A*X  B  using the QL factorization A = Q*L computed by SGEQLF.
[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 REAL array, dimension (LDA,N) Details of the QL factorization of the original matrix A as returned by SGEQLF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is REAL array, dimension (N) Details of the orthogonal matrix Q. 
[in,out]  B  B is REAL 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 REAL 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 sgeqls.f.
subroutine sgeqrs  (  integer  M, 
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
SGEQRS
Solve the least squares problem min  A*X  B  using the QR factorization A = Q*R computed by SGEQRF.
[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 REAL array, dimension (LDA,N) Details of the QR factorization of the original matrix A as returned by SGEQRF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is REAL array, dimension (N) Details of the orthogonal matrix Q. 
[in,out]  B  B is REAL 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 REAL 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 sgeqrs.f.
subroutine sgerqs  (  integer  M, 
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
SGERQS
Compute a minimumnorm solution min  A*X  B  using the RQ factorization A = R*Q computed by SGERQF.
[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 REAL array, dimension (LDA,N) Details of the RQ factorization of the original matrix A as returned by SGERQF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is REAL array, dimension (M) Details of the orthogonal matrix Q. 
[in,out]  B  B is REAL 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 REAL 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 sgerqs.f.
subroutine sget01  (  integer  M, 
integer  N,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
integer, dimension( * )  IPIV,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SGET01
SGET01 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 REAL 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 REAL 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 SGETRF. 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 SGETRF. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESID  RESID is REAL norm(L*U  A) / ( N * norm(A) * EPS ) 
Definition at line 107 of file sget01.f.
subroutine sget02  (  character  TRANS, 
integer  M,  
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SGET02
SGET02 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 REAL 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 REAL 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 REAL array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 133 of file sget02.f.
subroutine sget03  (  integer  N, 
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldainv, * )  AINV,  
integer  LDAINV,  
real, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
real, dimension( * )  RWORK,  
real  RCOND,  
real  RESID  
) 
SGET03
SGET03 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 REAL 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 REAL 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 REAL array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RCOND  RCOND is REAL The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is REAL norm(I  AINV*A) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 109 of file sget03.f.
subroutine sget04  (  integer  N, 
integer  NRHS,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real  RCOND,  
real  RESID  
) 
SGET04
SGET04 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 REAL 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 REAL array, dimension( LDX, NRHS ) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  RCOND  RCOND is REAL The reciprocal of the condition number of the coefficient matrix in the system of equations. 
[out]  RESID  RESID is REAL The maximum over the NRHS solution vectors of ( norm(XXACT) * RCOND ) / ( norm(XACT) * EPS ) 
Definition at line 103 of file sget04.f.
REAL function sget06  (  real  RCOND, 
real  RCONDC  
) 
SGET06
SGET06 computes a test ratio to compare two values for RCOND.
[in]  RCOND  RCOND is REAL The estimate of the reciprocal of the condition number of A, as computed by SGECON. 
[in]  RCONDC  RCONDC is REAL The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(inv(A)). 
Definition at line 56 of file sget06.f.
subroutine sget07  (  character  TRANS, 
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
logical  CHKFERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
SGET07
SGET07 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 REAL 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 REAL 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 REAL 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 REAL array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is REAL array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  CHKFERR  CHKFERR is LOGICAL Set to .TRUE. to check FERR, .FALSE. not to check FERR. When the test system is illconditioned, the "true" solution in XACT may be incorrect. 
[in]  BERR  BERR is REAL array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) ) 
Definition at line 165 of file sget07.f.
subroutine sgtt01  (  integer  N, 
real, dimension( * )  DL,  
real, dimension( * )  D,  
real, dimension( * )  DU,  
real, dimension( * )  DLF,  
real, dimension( * )  DF,  
real, dimension( * )  DUF,  
real, dimension( * )  DU2,  
integer, dimension( * )  IPIV,  
real, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SGTT01
SGTT01 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 REAL array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is REAL array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is REAL array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  DLF  DLF is REAL array, dimension (N1) The (n1) multipliers that define the matrix L from the LU factorization of A. 
[in]  DF  DF is REAL array, dimension (N) The n diagonal elements of the upper triangular matrix U from the LU factorization of A. 
[in]  DUF  DUF is REAL array, dimension (N1) The (n1) elements of the first superdiagonal of U. 
[in]  DU2  DU2 is REAL 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 REAL array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL The scaled residual: norm(L*U  A) / (norm(A) * EPS) 
Definition at line 134 of file sgtt01.f.
subroutine sgtt02  (  character  TRANS, 
integer  N,  
integer  NRHS,  
real, dimension( * )  DL,  
real, dimension( * )  D,  
real, dimension( * )  DU,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real  RESID  
) 
SGTT02
SGTT02 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 REAL array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is REAL array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is REAL array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  X  X is REAL 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 REAL array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  op(A)*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RESID  RESID is REAL norm(B  op(A)*X) / (norm(A) * norm(X) * EPS) 
Definition at line 124 of file sgtt02.f.
subroutine sgtt05  (  character  TRANS, 
integer  N,  
integer  NRHS,  
real, dimension( * )  DL,  
real, dimension( * )  D,  
real, dimension( * )  DU,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
SGTT05
SGTT05 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 REAL array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is REAL array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is REAL array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  B  B is REAL 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 REAL 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 REAL array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is REAL array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is REAL array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 165 of file sgtt05.f.
subroutine slahilb  (  integer  N, 
integer  NRHS,  
real, dimension(lda, n)  A,  
integer  LDA,  
real, dimension(ldx, nrhs)  X,  
integer  LDX,  
real, dimension(ldb, nrhs)  B,  
integer  LDB,  
real, dimension(n)  WORK,  
integer  INFO  
) 
SLAHILB
SLAHILB 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 REAL 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 REAL array, dimension (LDX, NRHS) The generated exact solutions. Currently, the first NRHS columns of the inverse Hilbert matrix. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= N. 
[out]  B  B is REAL array, dimension (LDB, NRHS) The generated righthand sides. Currently, the first NRHS columns of LCM(1, 2, ..., 2*N1) * the identity matrix. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= N. 
[out]  WORK  WORK is REAL array, dimension (N) 
[out]  INFO  INFO is INTEGER = 0: successful exit = 1: N is too large; the data is still generated but may not be not exact. < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 125 of file slahilb.f.
subroutine slaord  (  character  JOB, 
integer  N,  
real, dimension( * )  X,  
integer  INCX  
) 
SLAORD
SLAORD 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 REAL 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 slaord.f.
subroutine slaptm  (  integer  N, 
integer  NRHS,  
real  ALPHA,  
real, dimension( * )  D,  
real, dimension( * )  E,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real  BETA,  
real, dimension( ldb, * )  B,  
integer  LDB  
) 
SLAPTM
SLAPTM 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 REAL The scalar alpha. ALPHA must be 1. or 1.; otherwise, it is assumed to be 0. 
[in]  D  D is REAL array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is REAL array, dimension (N1) The (n1) subdiagonal or superdiagonal elements of A. 
[in]  X  X is REAL array, dimension (LDX,NRHS) The N by NRHS matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(N,1). 
[in]  BETA  BETA is REAL The scalar beta. BETA must be 0., 1., or 1.; otherwise, it is assumed to be 1. 
[in,out]  B  B is REAL 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 slaptm.f.
subroutine slarhs  (  character*3  PATH, 
character  XTYPE,  
character  UPLO,  
character  TRANS,  
integer  M,  
integer  N,  
integer  KL,  
integer  KU,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
integer, dimension( 4 )  ISEED,  
integer  INFO  
) 
SLARHS
SLARHS 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 REAL 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) REAL 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 REAL 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 SLATMS). 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 slarhs.f.
subroutine slatb4  (  character*3  PATH, 
integer  IMAT,  
integer  M,  
integer  N,  
character  TYPE,  
integer  KL,  
integer  KU,  
real  ANORM,  
integer  MODE,  
real  CNDNUM,  
character  DIST  
) 
SLATB4
SLATB4 sets parameters for the matrix generator based on the type of matrix to be generated.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name. 
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  M  M is INTEGER The number of rows in the matrix to be generated. 
[in]  N  N is INTEGER The number of columns in the matrix to be generated. 
[out]  TYPE  TYPE is CHARACTER*1 The type of the matrix to be generated: = 'S': symmetric matrix = 'P': symmetric positive (semi)definite matrix = 'N': nonsymmetric matrix 
[out]  KL  KL is INTEGER The lower band width of the matrix to be generated. 
[out]  KU  KU is INTEGER The upper band width of the matrix to be generated. 
[out]  ANORM  ANORM is REAL The desired norm of the matrix to be generated. The diagonal matrix of singular values or eigenvalues is scaled by this value. 
[out]  MODE  MODE is INTEGER A key indicating how to choose the vector of eigenvalues. 
[out]  CNDNUM  CNDNUM is REAL The desired condition number. 
[out]  DIST  DIST is CHARACTER*1 The type of distribution to be used by the random number generator. 
Definition at line 120 of file slatb4.f.
subroutine slatb5  (  character*3  PATH, 
integer  IMAT,  
integer  N,  
character  TYPE,  
integer  KL,  
integer  KU,  
real  ANORM,  
integer  MODE,  
real  CNDNUM,  
character  DIST  
) 
SLATB5
SLATB5 sets parameters for the matrix generator based on the type of matrix to be generated.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name. 
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  N  N is INTEGER The number of rows and columns in the matrix to be generated. 
[out]  TYPE  TYPE is CHARACTER*1 The type of the matrix to be generated: = 'S': symmetric matrix = 'P': symmetric positive (semi)definite matrix = 'N': nonsymmetric matrix 
[out]  KL  KL is INTEGER The lower band width of the matrix to be generated. 
[out]  KU  KU is INTEGER The upper band width of the matrix to be generated. 
[out]  ANORM  ANORM is REAL The desired norm of the matrix to be generated. The diagonal matrix of singular values or eigenvalues is scaled by this value. 
[out]  MODE  MODE is INTEGER A key indicating how to choose the vector of eigenvalues. 
[out]  CNDNUM  CNDNUM is REAL The desired condition number. 
[out]  DIST  DIST is CHARACTER*1 The type of distribution to be used by the random number generator. 
Definition at line 114 of file slatb5.f.
subroutine slattb  (  integer  IMAT, 
character  UPLO,  
character  TRANS,  
character  DIAG,  
integer, dimension( 4 )  ISEED,  
integer  N,  
integer  KD,  
real, dimension( ldab, * )  AB,  
integer  LDAB,  
real, dimension( * )  B,  
real, dimension( * )  WORK,  
integer  INFO  
) 
SLATTB
SLATTB 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 SLATMS). 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 REAL 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 REAL array, dimension (N) 
[out]  WORK  WORK is REAL 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 slattb.f.
subroutine slattp  (  integer  IMAT, 
character  UPLO,  
character  TRANS,  
character  DIAG,  
integer, dimension( 4 )  ISEED,  
integer  N,  
real, dimension( * )  A,  
real, dimension( * )  B,  
real, dimension( * )  WORK,  
integer  INFO  
) 
SLATTP
SLATTP 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 SLATMS). Modified on exit. 
[in]  N  N is INTEGER The order of the matrix to be generated. 
[out]  A  A is REAL 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 REAL array, dimension (N) The right hand side vector, if IMAT > 10. 
[out]  WORK  WORK is REAL 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 slattp.f.
subroutine slattr  (  integer  IMAT, 
character  UPLO,  
character  TRANS,  
character  DIAG,  
integer, dimension( 4 )  ISEED,  
integer  N,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  B,  
real, dimension( * )  WORK,  
integer  INFO  
) 
SLATTR
SLATTR 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 SLATMS). Modified on exit. 
[in]  N  N is INTEGER The order of the matrix to be generated. 
[out]  A  A is REAL 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 REAL array, dimension (N) The right hand side vector, if IMAT > 10. 
[out]  WORK  WORK is REAL 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 slattr.f.
subroutine slavsp  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
real, dimension( * )  A,  
integer, dimension( * )  IPIV,  
real, dimension( ldb, * )  B,  
integer  LDB,  
integer  INFO  
) 
SLAVSP
SLAVSP 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 SSPTRF. 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 REAL 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 SSPTRF. 
[in]  IPIV  IPIV is INTEGER array, dimension (N) The pivot indices from SSPTRF. 
[in,out]  B  B is REAL 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 slavsp.f.
subroutine slavsy  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
integer, dimension( * )  IPIV,  
real, dimension( ldb, * )  B,  
integer  LDB,  
integer  INFO  
) 
SLAVSY
SLAVSY 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 SSYTRF. 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 REAL array, dimension (LDA,N) The block diagonal matrix D and the multipliers used to obtain the factor U or L as computed by SSYTRF. 
[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 SSYTRF. 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 REAL 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 slavsy.f.
subroutine slqt01  (  integer  M, 
integer  N,  
real, dimension( lda, * )  A,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  Q,  
real, dimension( lda, * )  L,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SLQT01
SLQT01 tests SGELQF, which computes the LQ factorization of an mbyn matrix A, and partially tests SORGLQ which forms the nbyn orthogonal matrix Q. SLQT01 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 REAL array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is REAL array, dimension (LDA,N) Details of the LQ factorization of A, as returned by SGELQF. See SGELQF for further details. 
[out]  Q  Q is REAL array, dimension (LDA,N) The nbyn orthogonal matrix Q. 
[out]  L  L is REAL 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 REAL array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by SGELQF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (max(M,N)) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( L  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 126 of file slqt01.f.
subroutine slqt02  (  integer  M, 
integer  N,  
integer  K,  
real, dimension( lda, * )  A,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  Q,  
real, dimension( lda, * )  L,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SLQT02
SLQT02 tests SORGLQ, 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, SLQT02 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 REAL array, dimension (LDA,N) The mbyn matrix A which was factorized by SLQT01. 
[in]  AF  AF is REAL array, dimension (LDA,N) Details of the LQ factorization of A, as returned by SGELQF. See SGELQF for further details. 
[out]  Q  Q is REAL array, dimension (LDA,N) 
[out]  L  L is REAL 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 REAL array, dimension (M) The scalar factors of the elementary reflectors corresponding to the LQ factorization in AF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( L  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 135 of file slqt02.f.
subroutine slqt03  (  integer  M, 
integer  N,  
integer  K,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  C,  
real, dimension( lda, * )  CC,  
real, dimension( lda, * )  Q,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SLQT03
SLQT03 tests SORMLQ, which computes Q*C, Q'*C, C*Q or C*Q'. SLQT03 compares the results of a call to SORMLQ with the results of forming Q explicitly by a call to SORGLQ and then performing matrix multiplication by a call to SGEMM.
[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 REAL array, dimension (LDA,N) Details of the LQ factorization of an mbyn matrix, as returned by SGELQF. See SGELQF for further details. 
[out]  C  C is REAL array, dimension (LDA,N) 
[out]  CC  CC is REAL array, dimension (LDA,N) 
[out]  Q  Q is REAL array, dimension (LDA,N) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q. 
[in]  TAU  TAU is REAL array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the LQ factorization in AF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of WORK. LWORK must be at least M, and should be M*NB, where NB is the blocksize for this environment. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an nbyn orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( N * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( N * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( N * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( N * norm(C) * EPS ) 
Definition at line 136 of file slqt03.f.
subroutine spbt01  (  character  UPLO, 
integer  N,  
integer  KD,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SPBT01
SPBT01 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 REAL 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 SPBTRF for further details. 
[in]  LDA  LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,KD+1). 
[in]  AFAC  AFAC is REAL 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 SPBTRF. 
[in]  LDAFAC  LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,KD+1). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
Definition at line 119 of file spbt01.f.
subroutine spbt02  (  character  UPLO, 
integer  N,  
integer  KD,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SPBT02
SPBT02 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 REAL 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 SPBTRF for further details. 
[in]  LDA  LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,KD+1). 
[in]  X  X is REAL 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 REAL array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 136 of file spbt02.f.
subroutine spbt05  (  character  UPLO, 
integer  N,  
integer  KD,  
integer  NRHS,  
real, dimension( ldab, * )  AB,  
integer  LDAB,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
SPBT05
SPBT05 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 REAL 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 REAL 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 REAL 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 REAL array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is REAL array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is REAL array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 171 of file spbt05.f.
subroutine spot01  (  character  UPLO, 
integer  N,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SPOT01
SPOT01 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 REAL 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 REAL array, dimension (LDAFAC,N) On entry, the factor L or U from the L*L' or U'*U factorization of A. Overwritten with the reconstructed matrix, and then with the difference L*L'  A (or U'*U  A). 
[in]  LDAFAC  LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
Definition at line 105 of file spot01.f.
subroutine spot02  (  character  UPLO, 
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SPOT02
SPOT02 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 REAL 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 REAL 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 REAL array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 127 of file spot02.f.
subroutine spot03  (  character  UPLO, 
integer  N,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldainv, * )  AINV,  
integer  LDAINV,  
real, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
real, dimension( * )  RWORK,  
real  RCOND,  
real  RESID  
) 
SPOT03
SPOT03 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 REAL 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 REAL 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 REAL array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RCOND  RCOND is REAL The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is REAL norm(I  A*AINV) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 125 of file spot03.f.
subroutine spot05  (  character  UPLO, 
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
SPOT05
SPOT05 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 REAL 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 REAL 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 REAL 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 REAL array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is REAL array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is REAL array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) ) 
Definition at line 164 of file spot05.f.
subroutine sppt01  (  character  UPLO, 
integer  N,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SPPT01
SPPT01 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 REAL array, dimension (N*(N+1)/2) The original symmetric matrix A, stored as a packed triangular matrix. 
[in,out]  AFAC  AFAC is REAL array, dimension (N*(N+1)/2) On entry, the factor L or U from the L*L' or U'*U factorization of A, stored as a packed triangular matrix. Overwritten with the reconstructed matrix, and then with the difference L*L'  A (or U'*U  A). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
Definition at line 94 of file sppt01.f.
subroutine sppt02  (  character  UPLO, 
integer  N,  
integer  NRHS,  
real, dimension( * )  A,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SPPT02
SPPT02 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 REAL array, dimension (N*(N+1)/2) The original symmetric matrix A, stored as a packed triangular matrix. 
[in]  X  X is REAL 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 REAL array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 122 of file sppt02.f.
subroutine sppt03  (  character  UPLO, 
integer  N,  
real, dimension( * )  A,  
real, dimension( * )  AINV,  
real, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
real, dimension( * )  RWORK,  
real  RCOND,  
real  RESID  
) 
SPPT03
SPPT03 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 REAL array, dimension (N*(N+1)/2) The original symmetric matrix A, stored as a packed triangular matrix. 
[in]  AINV  AINV is REAL array, dimension (N*(N+1)/2) The (symmetric) inverse of the matrix A, stored as a packed triangular matrix. 
[out]  WORK  WORK is REAL array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RCOND  RCOND is REAL The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is REAL norm(I  A*AINV) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 110 of file sppt03.f.
subroutine sppt05  (  character  UPLO, 
integer  N,  
integer  NRHS,  
real, dimension( * )  AP,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
SPPT05
SPPT05 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 REAL 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 REAL 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 REAL 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 REAL array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is REAL array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is REAL array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) ) 
Definition at line 156 of file sppt05.f.
subroutine spst01  (  character  UPLO, 
integer  N,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
real, dimension( ldperm, * )  PERM,  
integer  LDPERM,  
integer, dimension( * )  PIV,  
real, dimension( * )  RWORK,  
real  RESID,  
integer  RANK  
) 
SPST01
SPST01 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 REAL 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 REAL 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 REAL array, dimension (LDPERM,N) Overwritten with the reconstructed matrix, and then with the difference P*L*L'*P'  A (or P*U'*U*P'  A) 
[in]  LDPERM  LDPERM is INTEGER The leading dimension of the array PERM. LDAPERM >= max(1,N). 
[in]  PIV  PIV is INTEGER array, dimension (N) PIV is such that the nonzero entries are P( PIV( K ), K ) = 1. 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
[in]  RANK  RANK is INTEGER number of nonzero singular values of A. 
Definition at line 134 of file spst01.f.
subroutine sptt01  (  integer  N, 
real, dimension( * )  D,  
real, dimension( * )  E,  
real, dimension( * )  DF,  
real, dimension( * )  EF,  
real, dimension( * )  WORK,  
real  RESID  
) 
SPTT01
SPTT01 reconstructs a tridiagonal matrix A from its L*D*L' factorization and computes the residual norm(L*D*L'  A) / ( n * norm(A) * EPS ), where EPS is the machine epsilon.
[in]  N  N is INTEGTER The order of the matrix A. 
[in]  D  D is REAL array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is REAL array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  DF  DF is REAL array, dimension (N) The n diagonal elements of the factor L from the L*D*L' factorization of A. 
[in]  EF  EF is REAL array, dimension (N1) The (n1) subdiagonal elements of the factor L from the L*D*L' factorization of A. 
[out]  WORK  WORK is REAL array, dimension (2*N) 
[out]  RESID  RESID is REAL norm(L*D*L'  A) / (n * norm(A) * EPS) 
Definition at line 92 of file sptt01.f.
subroutine sptt02  (  integer  N, 
integer  NRHS,  
real, dimension( * )  D,  
real, dimension( * )  E,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real  RESID  
) 
SPTT02
SPTT02 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 REAL array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is REAL array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  X  X is REAL 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 REAL array, dimension (LDB,NRHS) On entry, the n by nrhs matrix of right hand side vectors B. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RESID  RESID is REAL norm(B  A*X) / (norm(A) * norm(X) * EPS) 
Definition at line 105 of file sptt02.f.
subroutine sptt05  (  integer  N, 
integer  NRHS,  
real, dimension( * )  D,  
real, dimension( * )  E,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
SPTT05
SPTT05 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 REAL array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is REAL array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  B  B is REAL 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 REAL 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 REAL array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is REAL array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is REAL array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 150 of file sptt05.f.
subroutine sqlt01  (  integer  M, 
integer  N,  
real, dimension( lda, * )  A,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  Q,  
real, dimension( lda, * )  L,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SQLT01
SQLT01 tests SGEQLF, which computes the QL factorization of an mbyn matrix A, and partially tests SORGQL which forms the mbym orthogonal matrix Q. SQLT01 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 REAL array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is REAL array, dimension (LDA,N) Details of the QL factorization of A, as returned by SGEQLF. See SGEQLF for further details. 
[out]  Q  Q is REAL array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  L  L is REAL 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 REAL array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by SGEQLF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( L  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 126 of file sqlt01.f.
subroutine sqlt02  (  integer  M, 
integer  N,  
integer  K,  
real, dimension( lda, * )  A,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  Q,  
real, dimension( lda, * )  L,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SQLT02
SQLT02 tests SORGQL, 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, SQLT02 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 REAL array, dimension (LDA,N) The mbyn matrix A which was factorized by SQLT01. 
[in]  AF  AF is REAL array, dimension (LDA,N) Details of the QL factorization of A, as returned by SGEQLF. See SGEQLF for further details. 
[out]  Q  Q is REAL array, dimension (LDA,N) 
[out]  L  L is REAL 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 REAL array, dimension (N) The scalar factors of the elementary reflectors corresponding to the QL factorization in AF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( L  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 136 of file sqlt02.f.
subroutine sqlt03  (  integer  M, 
integer  N,  
integer  K,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  C,  
real, dimension( lda, * )  CC,  
real, dimension( lda, * )  Q,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SQLT03
SQLT03 tests SORMQL, which computes Q*C, Q'*C, C*Q or C*Q'. SQLT03 compares the results of a call to SORMQL with the results of forming Q explicitly by a call to SORGQL and then performing matrix multiplication by a call to SGEMM.
[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 REAL array, dimension (LDA,N) Details of the QL factorization of an mbyn matrix, as returned by SGEQLF. See SGEQLF for further details. 
[out]  C  C is REAL array, dimension (LDA,N) 
[out]  CC  CC is REAL array, dimension (LDA,N) 
[out]  Q  Q is REAL array, dimension (LDA,M) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q. 
[in]  TAU  TAU is REAL array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the QL factorization in AF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of WORK. LWORK must be at least M, and should be M*NB, where NB is the blocksize for this environment. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an mbym orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( M * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( M * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( M * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( M * norm(C) * EPS ) 
Definition at line 136 of file sqlt03.f.
REAL function sqpt01  (  integer  M, 
integer  N,  
integer  K,  
real, dimension( lda, * )  A,  
real, dimension( lda, * )  AF,  
integer  LDA,  
real, dimension( * )  TAU,  
integer, dimension( * )  JPVT,  
real, dimension( lwork )  WORK,  
integer  LWORK  
) 
SQPT01
SQPT01 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 REAL array, dimension (LDA, N) The original matrix A. 
[in]  AF  AF is REAL array, dimension (LDA,N) The (possibly partial) output of SGEQPF. 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 REAL array, dimension (K) Details of the Householder transformations as returned by SGEQPF. 
[in]  JPVT  JPVT is INTEGER array, dimension (N) Pivot information as returned by SGEQPF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= M*N+N. 
Definition at line 120 of file sqpt01.f.
subroutine sqrt01  (  integer  M, 
integer  N,  
real, dimension( lda, * )  A,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  Q,  
real, dimension( lda, * )  R,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SQRT01
SQRT01 tests SGEQRF, which computes the QR factorization of an mbyn matrix A, and partially tests SORGQR which forms the mbym orthogonal matrix Q. SQRT01 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 REAL array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is REAL array, dimension (LDA,N) Details of the QR factorization of A, as returned by SGEQRF. See SGEQRF for further details. 
[out]  Q  Q is REAL array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  R  R is REAL 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 REAL array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by SGEQRF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( R  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 126 of file sqrt01.f.
subroutine sqrt01p  (  integer  M, 
integer  N,  
real, dimension( lda, * )  A,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  Q,  
real, dimension( lda, * )  R,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SQRT01P
SQRT01P tests SGEQRFP, which computes the QR factorization of an mbyn matrix A, and partially tests SORGQR which forms the mbym orthogonal matrix Q. SQRT01P 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 REAL array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is REAL array, dimension (LDA,N) Details of the QR factorization of A, as returned by SGEQRFP. See SGEQRFP for further details. 
[out]  Q  Q is REAL array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  R  R is REAL 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 REAL array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by SGEQRFP. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( R  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 126 of file sqrt01p.f.
subroutine sqrt02  (  integer  M, 
integer  N,  
integer  K,  
real, dimension( lda, * )  A,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  Q,  
real, dimension( lda, * )  R,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SQRT02
SQRT02 tests SORGQR, 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, SQRT02 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 REAL array, dimension (LDA,N) The mbyn matrix A which was factorized by SQRT01. 
[in]  AF  AF is REAL array, dimension (LDA,N) Details of the QR factorization of A, as returned by SGEQRF. See SGEQRF for further details. 
[out]  Q  Q is REAL array, dimension (LDA,N) 
[out]  R  R is REAL 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 REAL array, dimension (N) The scalar factors of the elementary reflectors corresponding to the QR factorization in AF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( R  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 135 of file sqrt02.f.
subroutine sqrt03  (  integer  M, 
integer  N,  
integer  K,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  C,  
real, dimension( lda, * )  CC,  
real, dimension( lda, * )  Q,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SQRT03
SQRT03 tests SORMQR, which computes Q*C, Q'*C, C*Q or C*Q'. SQRT03 compares the results of a call to SORMQR with the results of forming Q explicitly by a call to SORGQR and then performing matrix multiplication by a call to SGEMM.
[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 REAL array, dimension (LDA,N) Details of the QR factorization of an mbyn matrix, as returnedby SGEQRF. See SGEQRF for further details. 
[out]  C  C is REAL array, dimension (LDA,N) 
[out]  CC  CC is REAL array, dimension (LDA,N) 
[out]  Q  Q is REAL array, dimension (LDA,M) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q. 
[in]  TAU  TAU is REAL array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the QR factorization in AF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of WORK. LWORK must be at least M, and should be M*NB, where NB is the blocksize for this environment. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an mbym orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( M * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( M * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( M * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( M * norm(C) * EPS ) 
Definition at line 136 of file sqrt03.f.
subroutine sqrt04  (  integer  M, 
integer  N,  
integer  NB,  
real, dimension(6)  RESULT  
) 
SQRT04
SQRT04 tests SGEQRT and SGEMQRT.
[in]  M  M is INTEGER Number of rows in test matrix. 
[in]  N  N is INTEGER Number of columns in test matrix. 
[in]  NB  NB is INTEGER Block size of test matrix. NB <= Min(M,N). 
[out]  RESULT  RESULT is REAL array, dimension (6) Results of each of the six tests below. RESULT(1) =  A  Q R  RESULT(2) =  I  Q^H Q  RESULT(3) =  Q C  Q C  RESULT(4) =  Q^H C  Q^H C  RESULT(5) =  C Q  C Q  RESULT(6) =  C Q^H  C Q^H  
Definition at line 74 of file sqrt04.f.
subroutine sqrt05  (  integer  M, 
integer  N,  
integer  L,  
integer  NB,  
real, dimension(6)  RESULT  
) 
SQRT05
SQRT05 tests STPQRT and STPMQRT.
[in]  M  M is INTEGER Number of rows in lower part of the test matrix. 
[in]  N  N is INTEGER Number of columns in test matrix. 
[in]  L  L is INTEGER The number of rows of the upper trapezoidal part the lower test matrix. 0 <= L <= M. 
[in]  NB  NB is INTEGER Block size of test matrix. NB <= N. 
[out]  RESULT  RESULT is REAL array, dimension (6) Results of each of the six tests below. RESULT(1) =  A  Q R  RESULT(2) =  I  Q^H Q  RESULT(3) =  Q C  Q C  RESULT(4) =  Q^H C  Q^H C  RESULT(5) =  C Q  C Q  RESULT(6) =  C Q^H  C Q^H  
Definition at line 81 of file sqrt05.f.
REAL function sqrt11  (  integer  M, 
integer  K,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK  
) 
SQRT11
SQRT11 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 REAL 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 REAL array, dimension (K) The scaling factors tau for the elementary transformations as computed by the QR factorization routine. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= M*M + M. 
Definition at line 99 of file sqrt11.f.
REAL function sqrt12  (  integer  M, 
integer  N,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  S,  
real, dimension( lwork )  WORK,  
integer  LWORK  
) 
SQRT12
SQRT12 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 REAL array, dimension (LDA,N) The MbyN matrix A. Only the upper trapezoid is referenced. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[in]  S  S is REAL array, dimension (min(M,N)) The singular values of the matrix A. 
[out]  WORK  WORK is REAL 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 sqrt12.f.
subroutine sqrt13  (  integer  SCALE, 
integer  M,  
integer  N,  
real, dimension( lda, * )  A,  
integer  LDA,  
real  NORMA,  
integer, dimension( 4 )  ISEED  
) 
SQRT13
SQRT13 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 REAL array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[out]  NORMA  NORMA is REAL The onenorm of A. 
[in,out]  ISEED  ISEED is integer array, dimension (4) Seed for random number generator 
Definition at line 92 of file sqrt13.f.
REAL function sqrt14  (  character  TRANS, 
integer  M,  
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( lwork )  WORK,  
integer  LWORK  
) 
SQRT14
SQRT14 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 REAL array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[in]  X  X is REAL 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 REAL 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 sqrt14.f.
subroutine sqrt15  (  integer  SCALE, 
integer  RKSEL,  
integer  M,  
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  S,  
integer  RANK,  
real  NORMA,  
real  NORMB,  
integer, dimension( 4 )  ISEED,  
real, dimension( lwork )  WORK,  
integer  LWORK  
) 
SQRT15
SQRT15 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 REAL array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[out]  B  B is REAL array, dimension (LDB, NRHS) A matrix that is in the range space of matrix A. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. 
[out]  S  S is REAL array, dimension MIN(M,N) Singular values of A. 
[out]  RANK  RANK is INTEGER number of nonzero singular values of A. 
[out]  NORMA  NORMA is REAL onenorm of A. 
[out]  NORMB  NORMB is REAL onenorm of B. 
[in,out]  ISEED  ISEED is integer array, dimension (4) seed for random number generator. 
[out]  WORK  WORK is REAL 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 sqrt15.f.
subroutine sqrt16  (  character  TRANS, 
integer  M,  
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SQRT16
SQRT16 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 REAL 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 REAL 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 REAL array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(B  A*X) / ( max(m,n) * norm(A) * norm(X) * EPS ). 
Definition at line 133 of file sqrt16.f.
REAL function sqrt17  (  character  TRANS, 
integer  IRESID,  
integer  M,  
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( ldb, * )  C,  
real, dimension( lwork )  WORK,  
integer  LWORK  
) 
SQRT17
SQRT17 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 REAL 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 REAL 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 REAL 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 REAL array, dimension (LDB,NRHS) 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= NRHS*(M+N). 
Definition at line 150 of file sqrt17.f.
subroutine srqt01  (  integer  M, 
integer  N,  
real, dimension( lda, * )  A,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  Q,  
real, dimension( lda, * )  R,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SRQT01
SRQT01 tests SGERQF, which computes the RQ factorization of an mbyn matrix A, and partially tests SORGRQ which forms the nbyn orthogonal matrix Q. SRQT01 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 REAL array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is REAL array, dimension (LDA,N) Details of the RQ factorization of A, as returned by SGERQF. See SGERQF for further details. 
[out]  Q  Q is REAL array, dimension (LDA,N) The nbyn orthogonal matrix Q. 
[out]  R  R is REAL 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 REAL array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by SGERQF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (max(M,N)) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( R  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 126 of file srqt01.f.
subroutine srqt02  (  integer  M, 
integer  N,  
integer  K,  
real, dimension( lda, * )  A,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  Q,  
real, dimension( lda, * )  R,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SRQT02
SRQT02 tests SORGRQ, 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, SRQT02 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 REAL array, dimension (LDA,N) The mbyn matrix A which was factorized by SRQT01. 
[in]  AF  AF is REAL array, dimension (LDA,N) Details of the RQ factorization of A, as returned by SGERQF. See SGERQF for further details. 
[out]  Q  Q is REAL array, dimension (LDA,N) 
[out]  R  R is REAL 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 REAL array, dimension (M) The scalar factors of the elementary reflectors corresponding to the RQ factorization in AF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( R  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 136 of file srqt02.f.
subroutine srqt03  (  integer  M, 
integer  N,  
integer  K,  
real, dimension( lda, * )  AF,  
real, dimension( lda, * )  C,  
real, dimension( lda, * )  CC,  
real, dimension( lda, * )  Q,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
SRQT03
SRQT03 tests SORMRQ, which computes Q*C, Q'*C, C*Q or C*Q'. SRQT03 compares the results of a call to SORMRQ with the results of forming Q explicitly by a call to SORGRQ and then performing matrix multiplication by a call to SGEMM.
[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 REAL array, dimension (LDA,N) Details of the RQ factorization of an mbyn matrix, as returned by SGERQF. See SGERQF for further details. 
[out]  C  C is REAL array, dimension (LDA,N) 
[out]  CC  CC is REAL array, dimension (LDA,N) 
[out]  Q  Q is REAL array, dimension (LDA,N) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q. 
[in]  TAU  TAU is REAL array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the RQ factorization in AF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of WORK. LWORK must be at least M, and should be M*NB, where NB is the blocksize for this environment. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an nbyn orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( N * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( N * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( N * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( N * norm(C) * EPS ) 
Definition at line 136 of file srqt03.f.
REAL function srzt01  (  integer  M, 
integer  N,  
real, dimension( lda, * )  A,  
real, dimension( lda, * )  AF,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK  
) 
SRZT01
SRZT01 returns  A  R*Q  / ( M * eps * A ) for an upper trapezoidal A that was factored with STZRZF.
[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 REAL array, dimension (LDA,N) The original upper trapezoidal M by N matrix A. 
[in]  AF  AF is REAL array, dimension (LDA,N) The output of STZRZF 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 REAL array, dimension (M) Details of the Householder transformations as returned by STZRZF. 
[out]  WORK  WORK is REAL 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 srzt01.f.
REAL function srzt02  (  integer  M, 
integer  N,  
real, dimension( lda, * )  AF,  
integer  LDA,  
real, dimension( * )  TAU,  
real, dimension( lwork )  WORK,  
integer  LWORK  
) 
SRZT02
SRZT02 returns  I  Q'*Q  / ( M * eps) where the matrix Q is defined by the Householder transformations generated by STZRZF.
[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 REAL array, dimension (LDA,N) The output of STZRZF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array AF. 
[in]  TAU  TAU is REAL array, dimension (M) Details of the Householder transformations as returned by STZRZF. 
[out]  WORK  WORK is REAL array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER length of WORK array. LWORK >= N*N+N*NB. 
Definition at line 91 of file srzt02.f.
subroutine sspt01  (  character  UPLO, 
integer  N,  
real, dimension( * )  A,  
real, dimension( * )  AFAC,  
integer, dimension( * )  IPIV,  
real, dimension( ldc, * )  C,  
integer  LDC,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SSPT01
SSPT01 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 REAL array, dimension (N*(N+1)/2) The original symmetric matrix A, stored as a packed triangular matrix. 
[in]  AFAC  AFAC is REAL 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 SSPTRF. 
[in]  IPIV  IPIV is INTEGER array, dimension (N) The pivot indices from SSPTRF. 
[out]  C  C is REAL array, dimension (LDC,N) 
[in]  LDC  LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*D*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U*D*U'  A) / ( N * norm(A) * EPS ) 
Definition at line 111 of file sspt01.f.
subroutine ssyt01  (  character  UPLO, 
integer  N,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
integer, dimension( * )  IPIV,  
real, dimension( ldc, * )  C,  
integer  LDC,  
real, dimension( * )  RWORK,  
real  RESID  
) 
SSYT01
SSYT01 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 REAL 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 REAL 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 SSYTRF. 
[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 SSYTRF. 
[out]  C  C is REAL array, dimension (LDC,N) 
[in]  LDC  LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*D*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U*D*U'  A) / ( N * norm(A) * EPS ) 
Definition at line 124 of file ssyt01.f.
subroutine stbt02  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  KD,  
integer  NRHS,  
real, dimension( ldab, * )  AB,  
integer  LDAB,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  WORK,  
real  RESID  
) 
STBT02
STBT02 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 REAL 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 REAL 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 REAL 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 REAL array, dimension (N) 
[out]  RESID  RESID is REAL 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 stbt02.f.
subroutine stbt03  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  KD,  
integer  NRHS,  
real, dimension( ldab, * )  AB,  
integer  LDAB,  
real  SCALE,  
real, dimension( * )  CNORM,  
real  TSCAL,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  WORK,  
real  RESID  
) 
STBT03
STBT03 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 REAL 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 REAL The scaling factor s used in solving the triangular system. 
[in]  CNORM  CNORM is REAL array, dimension (N) The 1norms of the columns of A, not counting the diagonal. 
[in]  TSCAL  TSCAL is REAL The scaling factor used in computing the 1norms in CNORM. CNORM actually contains the column norms of TSCAL*A. 
[in]  X  X is REAL 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 REAL 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 REAL array, dimension (N) 
[out]  RESID  RESID is REAL 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 stbt03.f.
subroutine stbt05  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  KD,  
integer  NRHS,  
real, dimension( ldab, * )  AB,  
integer  LDAB,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
STBT05
STBT05 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 REAL 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 REAL 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 REAL 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 REAL array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is REAL array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is REAL array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 189 of file stbt05.f.
subroutine stbt06  (  real  RCOND, 
real  RCONDC,  
character  UPLO,  
character  DIAG,  
integer  N,  
integer  KD,  
real, dimension( ldab, * )  AB,  
integer  LDAB,  
real, dimension( * )  WORK,  
real  RAT  
) 
STBT06
STBT06 computes a test ratio comparing RCOND (the reciprocal condition number of a triangular matrix A) and RCONDC, the estimate computed by STBCON. 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 REAL 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 REAL The estimate of the reciprocal condition number computed by STBCON. 
[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 REAL 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 REAL array, dimension (N) 
[out]  RAT  RAT is REAL 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 stbt06.f.
subroutine stpt01  (  character  UPLO, 
character  DIAG,  
integer  N,  
real, dimension( * )  AP,  
real, dimension( * )  AINVP,  
real  RCOND,  
real, dimension( * )  WORK,  
real  RESID  
) 
STPT01
STPT01 computes the residual for a triangular matrix A times its inverse when A is stored in packed format: RESID = norm(A*AINV  I) / ( N * norm(A) * norm(AINV) * EPS ), where EPS is the machine epsilon.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the matrix A is upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[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]  AP  AP is REAL array, dimension (N*(N+1)/2) The original 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. 
[in,out]  AINVP  AINVP is REAL array, dimension (N*(N+1)/2) On entry, the (triangular) inverse of the matrix A, packed columnwise in a linear array as in AP. On exit, the contents of AINVP are destroyed. 
[out]  RCOND  RCOND is REAL The reciprocal condition number of A, computed as 1/(norm(A) * norm(AINV)). 
[out]  WORK  WORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL norm(A*AINV  I) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 109 of file stpt01.f.
subroutine stpt02  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
real, dimension( * )  AP,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  WORK,  
real  RESID  
) 
STPT02
STPT02 computes the residual for the computed solution to a triangular system of linear equations A*x = b or A'*x = b when the triangular matrix A is stored in packed format. 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]  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]  AP  AP is REAL 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. 
[in]  X  X is REAL 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 REAL 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 REAL array, dimension (N) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(op(A)*x  b) / ( norm(op(A)) * norm(x) * EPS ). 
Definition at line 141 of file stpt02.f.
subroutine stpt03  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
real, dimension( * )  AP,  
real  SCALE,  
real, dimension( * )  CNORM,  
real  TSCAL,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  WORK,  
real  RESID  
) 
STPT03
STPT03 computes the residual for the solution to a scaled triangular system of equations A*x = s*b or A'*x = s*b when the triangular matrix A is stored in packed format. 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 = s*b (No transpose) = 'T': A'*x = s*b (Transpose) = 'C': A'*x = s*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]  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]  AP  AP is REAL 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. 
[in]  SCALE  SCALE is REAL The scaling factor s used in solving the triangular system. 
[in]  CNORM  CNORM is REAL array, dimension (N) The 1norms of the columns of A, not counting the diagonal. 
[in]  TSCAL  TSCAL is REAL The scaling factor used in computing the 1norms in CNORM. CNORM actually contains the column norms of TSCAL*A. 
[in]  X  X is REAL 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 REAL 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 REAL array, dimension (N) 
[out]  RESID  RESID is REAL 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 161 of file stpt03.f.
subroutine stpt05  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
real, dimension( * )  AP,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
STPT05
STPT05 tests the error bounds from iterative refinement for the computed solution to a system of equations A*X = B, where A is a triangular matrix in packed storage format. RESLTS(1) = test of the error bound = norm(X  XACT) / ( norm(X) * FERR ) A large value is returned if this ratio is not less than one. RESLTS(2) = residual from the iterative refinement routine = the maximum of BERR / ( (n+1)*EPS + (*) ), where (*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
[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]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  AP  AP is REAL 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(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. If DIAG = 'U', the diagonal elements of A are not referenced and are assumed to be 1. 
[in]  B  B is REAL 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 REAL 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 REAL array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  FERR  FERR is REAL array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  BERR  BERR is REAL array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution). 
[out]  RESLTS  RESLTS is REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) ) 
Definition at line 174 of file stpt05.f.
subroutine stpt06  (  real  RCOND, 
real  RCONDC,  
character  UPLO,  
character  DIAG,  
integer  N,  
real, dimension( * )  AP,  
real, dimension( * )  WORK,  
real  RAT  
) 
STPT06
STPT06 computes a test ratio comparing RCOND (the reciprocal condition number of a triangular matrix A) and RCONDC, the estimate computed by STPCON. 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 REAL 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 REAL The estimate of the reciprocal condition number computed by STPCON. 
[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]  AP  AP is REAL 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]  WORK  WORK is REAL array, dimension (N) 
[out]  RAT  RAT is REAL 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 112 of file stpt06.f.
subroutine strt01  (  character  UPLO, 
character  DIAG,  
integer  N,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldainv, * )  AINV,  
integer  LDAINV,  
real  RCOND,  
real, dimension( * )  WORK,  
real  RESID  
) 
STRT01
STRT01 computes the residual for a triangular matrix A times its inverse: RESID = norm( A*AINV  I ) / ( N * norm(A) * norm(AINV) * EPS ), where EPS is the machine epsilon.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the matrix A is upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[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]  A  A is REAL array, dimension (LDA,N) The triangular matrix A. If UPLO = 'U', the leading n by n upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading n by n lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If DIAG = 'U', the diagonal elements of A are also not referenced and are assumed to be 1. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[in,out]  AINV  AINV is REAL array, dimension (LDAINV,N) On entry, the (triangular) inverse of the matrix A, in the same storage format as A. On exit, the contents of AINV are destroyed. 
[in]  LDAINV  LDAINV is INTEGER The leading dimension of the array AINV. LDAINV >= max(1,N). 
[out]  RCOND  RCOND is REAL The reciprocal condition number of A, computed as 1/(norm(A) * norm(AINV)). 
[out]  WORK  WORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL norm(A*AINV  I) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 124 of file strt01.f.
subroutine strt02  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  WORK,  
real  RESID  
) 
STRT02
STRT02 computes the residual for the computed solution to a triangular system of linear equations A*x = b or A'*x = b. Here A is a triangular matrix, 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]  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]  A  A is REAL array, dimension (LDA,N) The triangular matrix A. If UPLO = 'U', the leading n by n upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading n by n lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If DIAG = 'U', the diagonal elements of A are also not referenced and are assumed to be 1. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[in]  X  X is REAL 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 REAL 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 REAL array, dimension (N) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(op(A)*x  b) / ( norm(op(A)) * norm(x) * EPS ). 
Definition at line 150 of file strt02.f.
subroutine strt03  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
real, dimension( lda, * )  A,  
integer  LDA,  
real  SCALE,  
real, dimension( * )  CNORM,  
real  TSCAL,  
real, dimension( ldx, * )  X,  
integer  LDX,  
real, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  WORK,  
real  RESID  
) 
STRT03
STRT03 computes the residual for the solution to a scaled triangular system of equations A*x = s*b or A'*x = s*b. Here A is a triangular matrix, 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 = s*b (No transpose) = 'T': A'*x = s*b (Transpose) = 'C': A'*x = s*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]  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]  A  A is REAL array, dimension (LDA,N) The triangular matrix A. If UPLO = 'U', the leading n by n upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading n by n lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If DIAG = 'U', the diagonal elements of A are also not referenced and are assumed to be 1. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[in]  SCALE  SCALE is REAL The scaling factor s used in solving the triangular system. 
[in]  CNORM  CNORM is REAL array, dimension (N) The 1norms of the columns of A, not counting the diagonal. 
[in]  TSCAL  TSCAL is REAL The scaling factor used in computing the 1norms in CNORM. CNORM actually contains the column norms of TSCAL*A. 
[in]  X  X is REAL 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 REAL array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations. 
[in]  LDB 