Provided by: liblapack-doc-man_3.6.0-2ubuntu2_all 
NAME
single_lin - real
Functions
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 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 schksy_rook (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B,
X, XACT, WORK, RWORK, IWORK, NOUT)
SCHKSY_ROOK
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 slavsy_rook (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
SLAVSY_ROOK
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 ssyt01_rook (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
SSYT01_ROOK
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
Detailed Description
This is the group of real LAPACK TESTING LIN routines.
Function Documentation
program schkaa ()
SCHKAA
Purpose:
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 list-directed input. The remaining lines
specify the LAPACK test paths and the number of matrix types to use
in testing. An annotated example of a data file can be obtained by
deleting the first 3 characters from the following 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
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
subroutine schkeq (real THRESH, integer NOUT)
SCHKEQ
Purpose:
SCHKEQ tests SGEEQU, SGBEQU, SPOEQU, SPPEQU and SPBEQU
Parameters:
THRESH
THRESH is REAL
Threshold for testing routines. Should be between 2 and 10.
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SCHKGB tests SGBTRF, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is REAL array, dimension (LA)
LA
LA is INTEGER
The length of the array A. LA >= (KLMAX+KUMAX+1)*NMAX
where KLMAX is the largest entry in the local array KLVAL,
KUMAX is the largest entry in the local array KUVAL and
NMAX is the largest entry in the input array NVAL.
AFAC
AFAC is REAL array, dimension (LAFAC)
LAFAC
LAFAC is INTEGER
The length of the array AFAC. LAFAC >= (2*KLMAX+KUMAX+1)*NMAX
where KLMAX is the largest entry in the local array KLVAL,
KUMAX is the largest entry in the local array KUVAL and
NMAX is the largest entry in the input array NVAL.
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NSMAX,NMAX))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SCHKGE tests SGETRF, -TRI, -TRS, -RFS, and -CON.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
AINV
AINV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is REAL array, dimension
(max(2*NMAX,2*NSMAX+NWORK))
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
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
Purpose:
SCHKGT tests SGTTRF, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is REAL array, dimension (NMAX*4)
AF
AF is REAL array, dimension (NMAX*4)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SCHKLQ tests SGELQF, SORGLQ and SORMLQ.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AF
AF is REAL array, dimension (NMAX*NMAX)
AQ
AQ is REAL array, dimension (NMAX*NMAX)
AL
AL is REAL array, dimension (NMAX*NMAX)
AC
AC is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
TAU
TAU is REAL array, dimension (NMAX)
WORK
WORK is REAL array, dimension (NMAX*NMAX)
RWORK
RWORK is REAL array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine 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
Purpose:
SCHKPB tests SPBTRF, -TRS, -RFS, and -CON.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
AINV
AINV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SCHKPO tests SPOTRF, -TRI, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
AINV
AINV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SCHKPP tests SPPTRF, -TRI, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension
(NMAX*(NMAX+1)/2)
AFAC
AFAC is REAL array, dimension
(NMAX*(NMAX+1)/2)
AINV
AINV is REAL array, dimension
(NMAX*(NMAX+1)/2)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SCHKPS tests SPSTRF.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the block size NB.
NRANK
NRANK is INTEGER
The number of values of RANK contained in the vector RANKVAL.
RANKVAL
RANKVAL is INTEGER array, dimension (NBVAL)
The values of the block size NB.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
PERM
PERM is REAL array, dimension (NMAX*NMAX)
PIV
PIV is INTEGER array, dimension (NMAX)
WORK
WORK is REAL array, dimension (NMAX*3)
RWORK
RWORK is REAL array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SCHKPT tests SPTTRF, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is REAL array, dimension (NMAX*2)
D
D is REAL array, dimension (NMAX*2)
E
E is REAL array, dimension (NMAX*2)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NSMAX))
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SCHKQ3 tests SGEQP3.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
THRESH
THRESH is 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.
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.
COPYA
COPYA is REAL array, dimension (MMAX*NMAX)
S
S is REAL array, dimension
(min(MMAX,NMAX))
TAU
TAU is REAL array, dimension (MMAX)
WORK
WORK is REAL array, dimension
(MMAX*NMAX + 4*NMAX + MMAX)
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SCHKQL tests SGEQLF, SORGQL and SORMQL.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AF
AF is REAL array, dimension (NMAX*NMAX)
AQ
AQ is REAL array, dimension (NMAX*NMAX)
AL
AL is REAL array, dimension (NMAX*NMAX)
AC
AC is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
TAU
TAU is REAL array, dimension (NMAX)
WORK
WORK is REAL array, dimension (NMAX*NMAX)
RWORK
RWORK is REAL array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SCHKQR tests SGEQRF, SORGQR and SORMQR.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AF
AF is REAL array, dimension (NMAX*NMAX)
AQ
AQ is REAL array, dimension (NMAX*NMAX)
AR
AR is REAL array, dimension (NMAX*NMAX)
AC
AC is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
TAU
TAU is REAL array, dimension (NMAX)
WORK
WORK is REAL array, dimension (NMAX*NMAX)
RWORK
RWORK is REAL array, dimension (NMAX)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine schkqrt (real THRESH, logical TSTERR, integer NM, integer, dimension( * ) MVAL, integer NN,
integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL, integer NOUT)
SCHKQRT
Purpose:
SCHKQRT tests SGEQRT and SGEMQRT.
Parameters:
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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine schkqrtp (real THRESH, logical TSTERR, integer NM, integer, dimension( * ) MVAL, integer NN,
integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL, integer NOUT)
SCHKQRTP
Purpose:
SCHKQRTP tests STPQRT and STPMQRT.
Parameters:
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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
program schkrfp ()
SCHKRFP
Purpose:
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
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
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
Purpose:
SCHKRQ tests SGERQF, SORGRQ and SORMRQ.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AF
AF is REAL array, dimension (NMAX*NMAX)
AQ
AQ is REAL array, dimension (NMAX*NMAX)
AR
AR is REAL array, dimension (NMAX*NMAX)
AC
AC is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
TAU
TAU is REAL array, dimension (NMAX)
WORK
WORK is REAL array, dimension (NMAX*NMAX)
RWORK
RWORK is REAL array, dimension (NMAX)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine 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
Purpose:
SCHKSP tests SSPTRF, -TRI, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension
(NMAX*(NMAX+1)/2)
AFAC
AFAC is REAL array, dimension
(NMAX*(NMAX+1)/2)
AINV
AINV is REAL array, dimension
(NMAX*(NMAX+1)/2)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(2,NSMAX))
RWORK
RWORK is REAL array,
dimension (NMAX+2*NSMAX)
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SCHKSY tests SSYTRF, -TRI2, -TRS, -TRS2, -RFS, and -CON.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
AINV
AINV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension (NMAX*max(3,NSMAX))
RWORK
RWORK is REAL array, dimension (max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine schksy_rook (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_ROOK
Purpose:
SCHKSY_ROOK tests SSYTRF_ROOK, -TRI_ROOK, -TRS_ROOK,
and -CON_ROOK.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
AINV
AINV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension (NMAX*max(3,NSMAX))
RWORK
RWORK is REAL array, dimension (max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine 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
Purpose:
SCHKTB tests STBTRS, -RFS, and -CON, and SLATBS.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The leading dimension of the work arrays.
NMAX >= the maximum value of N in NVAL.
AB
AB is REAL array, dimension (NMAX*NMAX)
AINV
AINV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SCHKTP tests STPTRI, -TRS, -RFS, and -CON, and SLATPS
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The leading dimension of the work arrays. NMAX >= the
maximumm value of N in NVAL.
AP
AP is REAL array, dimension
(NMAX*(NMAX+1)/2)
AINVP
AINVP is REAL array, dimension
(NMAX*(NMAX+1)/2)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NSMAX))
IWORK
IWORK is INTEGER array, dimension (NMAX)
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NSMAX))
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SCHKTR tests STRTRI, -TRS, -RFS, and -CON, and SLATRS
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The leading dimension of the work arrays.
NMAX >= the maximum value of N in NVAL.
A
A is REAL array, dimension (NMAX*NMAX)
AINV
AINV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is REAL array, dimension (NMAX*NSMAX)
XACT
XACT is REAL array, dimension (NMAX*NSMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SCHKTZ tests STZRZF.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
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.
COPYA
COPYA is REAL array, dimension (MMAX*NMAX)
S
S is REAL array, dimension
(min(MMAX,NMAX))
TAU
TAU is REAL array, dimension (MMAX)
WORK
WORK is REAL array, dimension
(MMAX*NMAX + 4*NMAX + MMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine 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
Purpose:
SDRVGB tests the driver routines SGBSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is REAL array, dimension (LA)
LA
LA is INTEGER
The length of the array A. LA >= (2*NMAX-1)*NMAX
where NMAX is the largest entry in NVAL.
AFB
AFB is REAL array, dimension (LAFB)
LAFB
LAFB is INTEGER
The length of the array AFB. LAFB >= (3*NMAX-2)*NMAX
where NMAX is the largest entry in NVAL.
ASAV
ASAV is REAL array, dimension (LA)
B
B is REAL array, dimension (NMAX*NRHS)
BSAV
BSAV is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
S
S is REAL array, dimension (2*NMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NRHS,NMAX))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NRHS))
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
Purpose:
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.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is REAL array, dimension (LA)
LA
LA is INTEGER
The length of the array A. LA >= (2*NMAX-1)*NMAX
where NMAX is the largest entry in NVAL.
AFB
AFB is REAL array, dimension (LAFB)
LAFB
LAFB is INTEGER
The length of the array AFB. LAFB >= (3*NMAX-2)*NMAX
where NMAX is the largest entry in NVAL.
ASAV
ASAV is REAL array, dimension (LA)
B
B is REAL array, dimension (NMAX*NRHS)
BSAV
BSAV is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
S
S is REAL array, dimension (2*NMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NRHS,NMAX))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NRHS))
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SDRVGE tests the driver routines SGESV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
ASAV
ASAV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NRHS)
BSAV
BSAV is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
S
S is REAL array, dimension (2*NMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is REAL array, dimension (2*NRHS+NMAX)
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
Purpose:
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.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
ASAV
ASAV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NRHS)
BSAV
BSAV is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
S
S is REAL array, dimension (2*NMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is REAL array, dimension (2*NRHS+NMAX)
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
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
Purpose:
SDRVGT tests SGTSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand sides, NRHS >= 0.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is REAL array, dimension (NMAX*4)
AF
AF is REAL array, dimension (NMAX*4)
B
B is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NRHS))
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SDRVLS tests the least squares driver routines SGELS, SGELSS, SGELSY
and SGELSD.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
The matrix of type j is generated as follows:
j=1: A = U*D*V where U and V are random 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 rank-deficient.
j=5: The same of 4, but A is scaled up.
j=6: The same of 5, but A is scaled down.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
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.
COPYA
COPYA is REAL array, dimension (MMAX*NMAX)
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.
COPYB
COPYB is REAL array, dimension (MMAX*NSMAX)
C
C is REAL array, dimension (MMAX*NSMAX)
S
S is REAL array, dimension
(min(MMAX,NMAX))
COPYS
COPYS is REAL array, dimension
(min(MMAX,NMAX))
WORK
WORK is REAL array,
dimension (MMAX*NMAX + 4*NMAX + MMAX).
IWORK
IWORK is INTEGER array, dimension (15*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine 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
Purpose:
SDRVPB tests the driver routines SPBSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
ASAV
ASAV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NRHS)
BSAV
BSAV is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
S
S is REAL array, dimension (NMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is REAL array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SDRVPO tests the driver routines SPOSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
ASAV
ASAV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NRHS)
BSAV
BSAV is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
S
S is REAL array, dimension (NMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is REAL array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
Purpose:
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.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
ASAV
ASAV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NRHS)
BSAV
BSAV is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
S
S is REAL array, dimension (NMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is REAL array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine 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
Purpose:
SDRVPP tests the driver routines SPPSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension
(NMAX*(NMAX+1)/2)
AFAC
AFAC is REAL array, dimension
(NMAX*(NMAX+1)/2)
ASAV
ASAV is REAL array, dimension
(NMAX*(NMAX+1)/2)
B
B is REAL array, dimension (NMAX*NRHS)
BSAV
BSAV is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
S
S is REAL array, dimension (NMAX)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is REAL array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SDRVPT tests SPTSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is REAL array, dimension (NMAX*2)
D
D is REAL array, dimension (NMAX*2)
E
E is REAL array, dimension (NMAX*2)
B
B is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
WORK
WORK is REAL array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is REAL array, dimension
(max(NMAX,2*NRHS))
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine sdrvrf1 (integer NOUT, integer NN, integer, dimension( nn ) NVAL, real THRESH, real, dimension(
lda, * ) A, integer LDA, real, dimension( * ) ARF, real, dimension( * ) WORK)
SDRVRF1
Purpose:
SDRVRF1 tests the LAPACK RFP routines:
SLANSF
Parameters:
NOUT
NOUT is INTEGER
The unit number for output.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
THRESH
THRESH is 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.
A
A is REAL array, dimension (LDA,NMAX)
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,NMAX).
ARF
ARF is REAL array, dimension ((NMAX*(NMAX+1))/2).
WORK
WORK is REAL array, dimension ( NMAX )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SDRVRF2 tests the LAPACK RFP convertion routines.
Parameters:
NOUT
NOUT is INTEGER
The unit number for output.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
A
A is REAL array, dimension (LDA,NMAX)
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,NMAX).
ARF
ARF is REAL array, dimension ((NMAX*(NMAX+1))/2).
AP
AP is REAL array, dimension ((NMAX*(NMAX+1))/2).
ASAV
ASAV is REAL array, dimension (LDA,NMAX)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SDRVRF3 tests the LAPACK RFP routines:
STFSM
Parameters:
NOUT
NOUT is INTEGER
The unit number for output.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
THRESH
THRESH is 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.
A
A is REAL array, dimension (LDA,NMAX)
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,NMAX).
ARF
ARF is REAL array, dimension ((NMAX*(NMAX+1))/2).
B1
B1 is REAL array, dimension (LDA,NMAX)
B2
B2 is REAL array, dimension (LDA,NMAX)
S_WORK_SLANGE
S_WORK_SLANGE is REAL array, dimension (NMAX)
S_WORK_SGEQRF
S_WORK_SGEQRF is REAL array, dimension (NMAX)
TAU
TAU is REAL array, dimension (NMAX)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SDRVRF4 tests the LAPACK RFP routines:
SSFRK
Parameters:
NOUT
NOUT is INTEGER
The unit number for output.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
THRESH
THRESH is 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.
C1
C1 is REAL array,
dimension (LDC,NMAX)
C2
C2 is REAL array,
dimension (LDC,NMAX)
LDC
LDC is INTEGER
The leading dimension of the array A.
LDA >= max(1,NMAX).
CRF
CRF is REAL array,
dimension ((NMAX*(NMAX+1))/2).
A
A is REAL array,
dimension (LDA,NMAX)
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,NMAX).
S_WORK_SLANGE
S_WORK_SLANGE is REAL array, dimension (NMAX)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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 N-by-NRHS 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(X-XACT) * RCOND ) / ( norm(XACT) * EPS ),
where EPS is the machine precision, RCOND the condition number of A, and
norm( . ) the 1-norm for (1,2,3) and the inf-norm for (4).
Errors occur when INFO parameter is not as expected. Failures occur when
a test ratios is greater than THRES.
Parameters:
NOUT
NOUT is INTEGER
The unit number for output.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right-hand sides NRHS.
NNT
NNT is INTEGER
The number of values of MATRIX TYPE contained in the vector NTVAL.
NTVAL
NTVAL is INTEGER array, dimension (NNT)
The values of matrix type (between 0 and 9 for PO/PP/PF matrices).
THRESH
THRESH is 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.
A
A is REAL array, dimension (NMAX*NMAX)
ASAV
ASAV is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
AINV
AINV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*MAXRHS)
BSAV
BSAV is REAL array, dimension (NMAX*MAXRHS)
XACT
XACT is REAL array, dimension (NMAX*MAXRHS)
X
X is REAL array, dimension (NMAX*MAXRHS)
ARF
ARF is REAL array, dimension ((NMAX*(NMAX+1))/2)
ARFINV
ARFINV is REAL array, dimension ((NMAX*(NMAX+1))/2)
S_WORK_SLATMS
S_WORK_SLATMS is REAL array, dimension ( 3*NMAX )
S_WORK_SPOT01
S_WORK_SPOT01 is REAL array, dimension ( NMAX )
S_TEMP_SPOT02
S_TEMP_SPOT02 is REAL array, dimension ( NMAX*MAXRHS )
S_TEMP_SPOT03
S_TEMP_SPOT03 is REAL array, dimension ( NMAX*NMAX )
S_WORK_SLATMS
S_WORK_SLATMS is REAL array, dimension ( NMAX )
S_WORK_SLANSY
S_WORK_SLANSY is REAL array, dimension ( NMAX )
S_WORK_SPOT02
S_WORK_SPOT02 is REAL array, dimension ( NMAX )
S_WORK_SPOT03
S_WORK_SPOT03 is REAL array, dimension ( NMAX )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
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
Purpose:
SDRVSP tests the driver routines SSPSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension
(NMAX*(NMAX+1)/2)
AFAC
AFAC is REAL array, dimension
(NMAX*(NMAX+1)/2)
AINV
AINV is REAL array, dimension
(NMAX*(NMAX+1)/2)
B
B is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
WORK
WORK is REAL array, dimension
(NMAX*max(2,NRHS))
RWORK
RWORK is REAL array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SDRVSY tests the driver routines SSYSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
AINV
AINV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
WORK
WORK is REAL array, dimension (NMAX*max(2,NRHS))
RWORK
RWORK is REAL array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
Purpose:
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.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is REAL array, dimension (NMAX*NMAX)
AFAC
AFAC is REAL array, dimension (NMAX*NMAX)
AINV
AINV is REAL array, dimension (NMAX*NMAX)
B
B is REAL array, dimension (NMAX*NRHS)
X
X is REAL array, dimension (NMAX*NRHS)
XACT
XACT is REAL array, dimension (NMAX*NRHS)
WORK
WORK is REAL array, dimension
(NMAX*max(2,NRHS))
RWORK
RWORK is REAL array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine sebchvxx (real THRESH, character*3 PATH)
SEBCHVXX
Purpose:
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.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrge (character*3 PATH, integer NUNIT)
SERRGE SERRGEX
Purpose:
SERRGE tests the error exits for the REAL routines
for general matrices.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
Purpose:
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.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrgt (character*3 PATH, integer NUNIT)
SERRGT
Purpose:
SERRGT tests the error exits for the REAL tridiagonal
routines.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrlq (character*3 PATH, integer NUNIT)
SERRLQ
Purpose:
SERRLQ tests the error exits for the REAL routines
that use the LQ decomposition of a general matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrls (character*3 PATH, integer NUNIT)
SERRLS
Purpose:
SERRLS tests the error exits for the REAL least squares
driver routines (SGELS, SGELSS, SGELSY, SGELSD).
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine serrpo (character*3 PATH, integer NUNIT)
SERRPO SERRPOX
Purpose:
SERRPO tests the error exits for the REAL routines
for symmetric positive definite matrices.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
Purpose:
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.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine serrps (character*3 PATH, integer NUNIT)
SERRPS
Purpose:
SERRPS tests the error exits for the REAL routines
for SPSTRF..
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrql (character*3 PATH, integer NUNIT)
SERRQL
Purpose:
SERRQL tests the error exits for the REAL routines
that use the QL decomposition of a general matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrqp (character*3 PATH, integer NUNIT)
SERRQP
Purpose:
SERRQP tests the error exits for SGEQP3.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine serrqr (character*3 PATH, integer NUNIT)
SERRQR
Purpose:
SERRQR tests the error exits for the REAL routines
that use the QR decomposition of a general matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrqrt (character*3 PATH, integer NUNIT)
SERRQRT
Purpose:
SERRQRT tests the error exits for the REAL routines
that use the QRT decomposition of a general matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrqrtp (character*3 PATH, integer NUNIT)
SERRQRTP
Purpose:
SERRQRTP tests the error exits for the REAL routines
that use the QRT decomposition of a triangular-pentagonal matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrrfp (integer NUNIT)
SERRRFP
Purpose:
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
Parameters:
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrrq (character*3 PATH, integer NUNIT)
SERRRQ
Purpose:
SERRRQ tests the error exits for the REAL routines
that use the RQ decomposition of a general matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrsy (character*3 PATH, integer NUNIT)
SERRSY SERRSYX
Purpose:
SERRSY tests the error exits for the REAL routines
for symmetric indefinite matrices.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
Purpose:
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.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine serrtr (character*3 PATH, integer NUNIT)
SERRTR
Purpose:
SERRTR tests the error exits for the REAL triangular
routines.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine serrtz (character*3 PATH, integer NUNIT)
SERRTZ
Purpose:
SERRTZ tests the error exits for STZRZF.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine serrvx (character*3 PATH, integer NUNIT)
SERRVX SERRVXX
Purpose:
SERRVX tests the error exits for the REAL driver routines
for solving linear systems of equations.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
Purpose:
SERRVX tests the error exits for the REAL driver routines
for solving linear systems of equations.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine 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
Purpose:
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.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
KL
KL is INTEGER
The number of subdiagonals within the band of A. KL >= 0.
KU
KU is INTEGER
The number of superdiagonals within the band of A. KU >= 0.
A
A is REAL array, dimension (LDA,N)
The original matrix A in band storage, stored in rows 1 to
KL+KU+1.
LDA
LDA is INTEGER.
The leading dimension of the array A. LDA >= max(1,KL+KU+1).
AFAC
AFAC is 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.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC.
LDAFAC >= max(1,2*KL*KU+1).
IPIV
IPIV is INTEGER array, dimension (min(M,N))
The pivot indices from SGBTRF.
WORK
WORK is REAL array, dimension (2*KL+KU+1)
RESID
RESID is REAL
norm(L*U - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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.
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations:
= 'N': A *x = b
= 'T': A'*x = b, where A' is the transpose of A
= 'C': A'*x = b, where A' is the transpose of A
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
KL
KL is INTEGER
The number of subdiagonals within the band of A. KL >= 0.
KU
KU is INTEGER
The number of superdiagonals within the band of A. KU >= 0.
NRHS
NRHS is INTEGER
The number of columns of B. NRHS >= 0.
A
A is REAL array, dimension (LDA,N)
The original matrix A in band storage, stored in rows 1 to
KL+KU+1.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,KL+KU+1).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
B
B is 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.
LDB
LDB is INTEGER
The leading dimension of the array B. IF TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
RESID
RESID is REAL
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A**T * X = B (Transpose)
= 'C': A**H * X = B (Conjugate transpose = Transpose)
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
KL
KL is INTEGER
The number of subdiagonals within the band of A. KL >= 0.
KU
KU is INTEGER
The number of superdiagonals within the band of A. KU >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
AB
AB is REAL array, dimension (LDAB,N)
The original band matrix A, stored in rows 1 to KL+KU+1.
The j-th column of A is stored in the j-th column of the
array AB as follows:
AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KL+KU+1.
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is REAL array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is 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.
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).
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 + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
Compute a minimum-norm solution
min || A*X - B ||
using the LQ factorization
A = L*Q
computed by SGELQF.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= M >= 0.
NRHS
NRHS is INTEGER
The number of columns of B. NRHS >= 0.
A
A is REAL array, dimension (LDA,N)
Details of the LQ factorization of the original matrix A as
returned by SGELQF.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= M.
TAU
TAU is REAL array, dimension (M)
Details of the orthogonal matrix Q.
B
B is REAL array, dimension (LDB,NRHS)
On entry, the m-by-nrhs right hand side matrix B.
On exit, the n-by-nrhs solution matrix X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= N.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK must be at least NRHS,
and should be at least NRHS*NB, where NB is the block size
for this environment.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
logical function sgennd (integer M, integer N, real, dimension( lda, * ) A, integer LDA)
SGENND
Purpose:
SGENND tests that its argument has a non-negative diagonal.
Parameters:
M
M is INTEGER
The number of rows in A.
N
N is INTEGER
The number of columns in A.
A
A is REAL array, dimension (LDA, N)
The matrix.
LDA
LDA is INTEGER
Leading dimension of A.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
Solve the least squares problem
min || A*X - B ||
using the QL factorization
A = Q*L
computed by SGEQLF.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. M >= N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B. NRHS >= 0.
A
A is REAL array, dimension (LDA,N)
Details of the QL factorization of the original matrix A as
returned by SGEQLF.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= M.
TAU
TAU is REAL array, dimension (N)
Details of the orthogonal matrix Q.
B
B is REAL array, dimension (LDB,NRHS)
On entry, the m-by-nrhs right hand side matrix B.
On exit, the n-by-nrhs solution matrix X, stored in rows
m-n+1:m.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= M.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK must be at least NRHS,
and should be at least NRHS*NB, where NB is the block size
for this environment.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
Solve the least squares problem
min || A*X - B ||
using the QR factorization
A = Q*R
computed by SGEQRF.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. M >= N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B. NRHS >= 0.
A
A is REAL array, dimension (LDA,N)
Details of the QR factorization of the original matrix A as
returned by SGEQRF.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= M.
TAU
TAU is REAL array, dimension (N)
Details of the orthogonal matrix Q.
B
B is REAL array, dimension (LDB,NRHS)
On entry, the m-by-nrhs right hand side matrix B.
On exit, the n-by-nrhs solution matrix X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= M.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK must be at least NRHS,
and should be at least NRHS*NB, where NB is the block size
for this environment.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
Compute a minimum-norm solution
min || A*X - B ||
using the RQ factorization
A = R*Q
computed by SGERQF.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= M >= 0.
NRHS
NRHS is INTEGER
The number of columns of B. NRHS >= 0.
A
A is REAL array, dimension (LDA,N)
Details of the RQ factorization of the original matrix A as
returned by SGERQF.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= M.
TAU
TAU is REAL array, dimension (M)
Details of the orthogonal matrix Q.
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.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK must be at least NRHS,
and should be at least NRHS*NB, where NB is the block size
for this environment.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The original M x N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,M).
AFAC
AFAC is 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.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,M).
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from SGETRF.
RWORK
RWORK is REAL array, dimension (M)
RESID
RESID is REAL
norm(L*U - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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.
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations:
= 'N': A *x = b
= 'T': A'*x = b, where A' is the transpose of A
= 'C': A'*x = b, where A' is the transpose of A
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is REAL array, dimension (LDA,N)
The original M x N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,M).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
B
B is 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.
LDB
LDB is INTEGER
The leading dimension of the array B. IF TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
RWORK
RWORK is REAL array, dimension (M)
RESID
RESID is REAL
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine 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
Purpose:
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.
Parameters:
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The original N x N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
AINV
AINV is REAL array, dimension (LDAINV,N)
The inverse of the matrix A.
LDAINV
LDAINV is INTEGER
The leading dimension of the array AINV. LDAINV >= max(1,N).
WORK
WORK is REAL array, dimension (LDWORK,N)
LDWORK
LDWORK is INTEGER
The leading dimension of the array WORK. LDWORK >= max(1,N).
RWORK
RWORK is REAL array, dimension (N)
RCOND
RCOND is REAL
The reciprocal of the condition number of A, computed as
( 1/norm(A) ) / norm(AINV).
RESID
RESID is REAL
norm(I - AINV*A) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine sget04 (integer N, integer NRHS, real, dimension( ldx, * ) X, integer LDX, real, dimension(
ldxact, * ) XACT, integer LDXACT, real RCOND, real RESID)
SGET04
Purpose:
SGET04 computes the difference between a computed solution and the
true solution to a system of linear equations.
RESID = ( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS ),
where RCOND is the reciprocal of the condition number and EPS is the
machine epsilon.
Parameters:
N
N is INTEGER
The number of rows of the matrices X and XACT. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X and XACT. NRHS >= 0.
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is REAL array, dimension( LDX, NRHS )
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
RCOND
RCOND is REAL
The reciprocal of the condition number of the coefficient
matrix in the system of equations.
RESID
RESID is REAL
The maximum over the NRHS solution vectors of
( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
real function sget06 (real RCOND, real RCONDC)
SGET06
Purpose:
SGET06 computes a test ratio to compare two values for RCOND.
Parameters:
RCOND
RCOND is REAL
The estimate of the reciprocal of the condition number of A,
as computed by SGECON.
RCONDC
RCONDC is REAL
The reciprocal of the condition number of A, computed as
( 1/norm(A) ) / norm(inv(A)).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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 )
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A**T * X = B (Transpose)
= 'C': A**H * X = B (Conjugate transpose = Transpose)
N
N is INTEGER
The number of rows of the matrices X and XACT. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X and XACT. NRHS >= 0.
A
A is REAL array, dimension (LDA,N)
The original n by n matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is REAL array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is 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.
CHKFERR
CHKFERR is LOGICAL
Set to .TRUE. to check FERR, .FALSE. not to check FERR.
When the test system is ill-conditioned, the "true"
solution in XACT may be incorrect.
BERR
BERR is 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).
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 + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
N
N is INTEGTER
The order of the matrix A. N >= 0.
DL
DL is REAL array, dimension (N-1)
The (n-1) sub-diagonal elements of A.
D
D is REAL array, dimension (N)
The diagonal elements of A.
DU
DU is REAL array, dimension (N-1)
The (n-1) super-diagonal elements of A.
DLF
DLF is REAL array, dimension (N-1)
The (n-1) multipliers that define the matrix L from the
LU factorization of A.
DF
DF is REAL array, dimension (N)
The n diagonal elements of the upper triangular matrix U from
the LU factorization of A.
DUF
DUF is REAL array, dimension (N-1)
The (n-1) elements of the first super-diagonal of U.
DU2
DU2 is REAL array, dimension (N-2)
The (n-2) elements of the second super-diagonal of U.
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices; for 1 <= i <= n, row i of the matrix was
interchanged with row IPIV(i). IPIV(i) will always be either
i or i+1; IPIV(i) = i indicates a row interchange was not
required.
WORK
WORK is REAL array, dimension (LDWORK,N)
LDWORK
LDWORK is INTEGER
The leading dimension of the array WORK. LDWORK >= max(1,N).
RWORK
RWORK is REAL array, dimension (N)
RESID
RESID is REAL
The scaled residual: norm(L*U - A) / (norm(A) * EPS)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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.
Parameters:
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)
N
N is INTEGTER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices B and X. NRHS >= 0.
DL
DL is REAL array, dimension (N-1)
The (n-1) sub-diagonal elements of A.
D
D is REAL array, dimension (N)
The diagonal elements of A.
DU
DU is REAL array, dimension (N-1)
The (n-1) super-diagonal elements of A.
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is 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.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RESID
RESID is REAL
norm(B - op(A)*X) / (norm(A) * norm(X) * EPS)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A**T * X = B (Transpose)
= 'C': A**H * X = B (Conjugate transpose = Transpose)
N
N is INTEGER
The number of rows of the matrices X and XACT. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X and XACT. NRHS >= 0.
DL
DL is REAL array, dimension (N-1)
The (n-1) sub-diagonal elements of A.
D
D is REAL array, dimension (N)
The diagonal elements of A.
DU
DU is REAL array, dimension (N-1)
The (n-1) super-diagonal elements of A.
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is REAL array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is 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.
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).
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 + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SLAHILB generates an N by N scaled Hilbert matrix in A along with
NRHS right-hand sides in B and solutions in X such that A*X=B.
The Hilbert matrix is scaled by M = LCM(1, 2, ..., 2*N-1) so that all
entries are integers. The right-hand sides are the first NRHS
columns of M * the identity matrix, and the solutions are the
first NRHS columns of the inverse Hilbert matrix.
The condition number of the Hilbert matrix grows exponentially with
its size, roughly as O(e ** (3.5*N)). Additionally, the inverse
Hilbert matrices beyond a relatively small dimension cannot be
generated exactly without extra precision. Precision is exhausted
when the largest entry in the inverse Hilbert matrix is greater than
2 to the power of the number of bits in the fraction of the data type
used plus one, which is 24 for single precision.
In single, the generated solution is exact for N <= 6 and has
small componentwise error for 7 <= N <= 11.
Parameters:
N
N is INTEGER
The dimension of the matrix A.
NRHS
NRHS is NRHS
The requested number of right-hand sides.
A
A is REAL array, dimension (LDA, N)
The generated scaled Hilbert matrix.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= N.
X
X is REAL array, dimension (LDX, NRHS)
The generated exact solutions. Currently, the first NRHS
columns of the inverse Hilbert matrix.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= N.
B
B is REAL array, dimension (LDB, NRHS)
The generated right-hand sides. Currently, the first NRHS
columns of LCM(1, 2, ..., 2*N-1) * the identity matrix.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= N.
WORK
WORK is REAL array, dimension (N)
INFO
INFO is INTEGER
= 0: successful exit
= 1: N is too large; the data is still generated but may not
be not exact.
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine slaord (character JOB, integer N, real, dimension( * ) X, integer INCX)
SLAORD
Purpose:
SLAORD sorts the elements of a vector x in increasing or decreasing
order.
Parameters:
JOB
JOB is CHARACTER
= 'I': Sort in increasing order
= 'D': Sort in decreasing order
N
N is INTEGER
The length of the vector X.
X
X is REAL array, dimension
(1+(N-1)*INCX)
On entry, the vector of length n to be sorted.
On exit, the vector x is sorted in the prescribed order.
INCX
INCX is INTEGER
The spacing between successive elements of X. INCX >= 0.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
N
N is INTEGER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B.
ALPHA
ALPHA is REAL
The scalar alpha. ALPHA must be 1. or -1.; otherwise,
it is assumed to be 0.
D
D is REAL array, dimension (N)
The n diagonal elements of the tridiagonal matrix A.
E
E is REAL array, dimension (N-1)
The (n-1) subdiagonal or superdiagonal elements of A.
X
X is REAL array, dimension (LDX,NRHS)
The N by NRHS matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(N,1).
BETA
BETA is REAL
The scalar beta. BETA must be 0., 1., or -1.; otherwise,
it is assumed to be 1.
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.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(N,1).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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).
Parameters:
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, 2-D storage
xPP: Symmetric positive definite packed
xPB: Symmetric positive definite banded
xSY: Symmetric indefinite, 2-D storage
xSP: Symmetric indefinite packed
xSB: Symmetric indefinite banded
xTR: Triangular
xTP: Triangular packed
xTB: Triangular banded
xQR: General m x n matrix
xLQ: General m x n matrix
xQL: General m x n matrix
xRQ: General m x n matrix
where the leading character indicates the precision.
XTYPE
XTYPE is CHARACTER*1
Specifies how the exact solution X will be determined:
= 'N': New solution; generate a random X.
= 'C': Computed; use value of X on entry.
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
matrix A is stored, if A is symmetric.
= 'U': Upper triangular
= 'L': Lower triangular
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
M
M is INTEGER
The number or rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
KL
KL is INTEGER
Used only if A is a band matrix; specifies the number of
subdiagonals of A if A is a general band matrix or if A is
symmetric or triangular and UPLO = 'L'; specifies the number
of superdiagonals of A if A is symmetric or triangular and
UPLO = 'U'. 0 <= KL <= M-1.
KU
KU is INTEGER
Used only if A is a general band matrix or if A is
triangular.
If PATH = xGB, specifies the number of superdiagonals of A,
and 0 <= KU <= N-1.
If PATH = xTR, xTP, or xTB, specifies whether or not the
matrix has unit diagonal:
= 1: matrix has non-unit diagonal (default)
= 2: matrix has unit diagonal
NRHS
NRHS is INTEGER
The number of right hand side vectors in the system A*X = B.
A
A is REAL array, dimension (LDA,N)
The test matrix whose type is given by PATH.
LDA
LDA is INTEGER
The leading dimension of the array A.
If PATH = xGB, LDA >= KL+KU+1.
If PATH = xPB, xSB, xHB, or xTB, LDA >= KL+1.
Otherwise, LDA >= max(1,M).
X
X is or output) 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.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T', LDX >= max(1,M).
B
B is 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.
LDB
LDB is INTEGER
The leading dimension of the array B. If TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T', LDB >= max(1,N).
ISEED
ISEED is INTEGER array, dimension (4)
The seed vector for the random number generator (used in
SLATMS). Modified on exit.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SLATB4 sets parameters for the matrix generator based on the type of
matrix to be generated.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name.
IMAT
IMAT is INTEGER
An integer key describing which matrix to generate for this
path.
M
M is INTEGER
The number of rows in the matrix to be generated.
N
N is INTEGER
The number of columns in the matrix to be generated.
TYPE
TYPE is CHARACTER*1
The type of the matrix to be generated:
= 'S': symmetric matrix
= 'P': symmetric positive (semi)definite matrix
= 'N': nonsymmetric matrix
KL
KL is INTEGER
The lower band width of the matrix to be generated.
KU
KU is INTEGER
The upper band width of the matrix to be generated.
ANORM
ANORM is REAL
The desired norm of the matrix to be generated. The diagonal
matrix of singular values or eigenvalues is scaled by this
value.
MODE
MODE is INTEGER
A key indicating how to choose the vector of eigenvalues.
CNDNUM
CNDNUM is REAL
The desired condition number.
DIST
DIST is CHARACTER*1
The type of distribution to be used by the random number
generator.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine slatb5 (character*3 PATH, integer IMAT, integer N, character TYPE, integer KL, integer KU, real
ANORM, integer MODE, real CNDNUM, character DIST)
SLATB5
Purpose:
SLATB5 sets parameters for the matrix generator based on the type
of matrix to be generated.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name.
IMAT
IMAT is INTEGER
An integer key describing which matrix to generate for this
path.
N
N is INTEGER
The number of rows and columns in the matrix to be generated.
TYPE
TYPE is CHARACTER*1
The type of the matrix to be generated:
= 'S': symmetric matrix
= 'P': symmetric positive (semi)definite matrix
= 'N': nonsymmetric matrix
KL
KL is INTEGER
The lower band width of the matrix to be generated.
KU
KU is INTEGER
The upper band width of the matrix to be generated.
ANORM
ANORM is REAL
The desired norm of the matrix to be generated. The diagonal
matrix of singular values or eigenvalues is scaled by this
value.
MODE
MODE is INTEGER
A key indicating how to choose the vector of eigenvalues.
CNDNUM
CNDNUM is REAL
The desired condition number.
DIST
DIST is CHARACTER*1
The type of distribution to be used by the random number
generator.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SLATTB generates a triangular test matrix in 2-dimensional storage.
IMAT and UPLO uniquely specify the properties of the test matrix,
which is returned in the array A.
Parameters:
IMAT
IMAT is INTEGER
An integer key describing which matrix to generate for this
path.
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A will be upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies whether the matrix or its transpose will be used.
= 'N': No transpose
= 'T': Transpose
= 'C': Conjugate transpose (= transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
ISEED
ISEED is INTEGER array, dimension (4)
The seed vector for the random number generator (used in
SLATMS). Modified on exit.
N
N is INTEGER
The order of the matrix to be generated.
KD
KD is INTEGER
The number of superdiagonals or subdiagonals of the banded
triangular matrix A. KD >= 0.
AB
AB is 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+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j.
If UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
B
B is REAL array, dimension (N)
WORK
WORK is REAL array, dimension (2*N)
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -k, the k-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
IMAT
IMAT is INTEGER
An integer key describing which matrix to generate for this
path.
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A will be upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies whether the matrix or its transpose will be used.
= 'N': No transpose
= 'T': Transpose
= 'C': Conjugate transpose (= Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
ISEED
ISEED is INTEGER array, dimension (4)
The seed vector for the random number generator (used in
SLATMS). Modified on exit.
N
N is INTEGER
The order of the matrix to be generated.
A
A is REAL array, dimension (N*(N+1)/2)
The upper or lower triangular matrix A, packed columnwise in
a linear array. The j-th column of A is stored in the array
AP as follows:
if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
if UPLO = 'L',
AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.
B
B is REAL array, dimension (N)
The right hand side vector, if IMAT > 10.
WORK
WORK is REAL array, dimension (3*N)
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -k, the k-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SLATTR generates a triangular test matrix.
IMAT and UPLO uniquely specify the properties of the test
matrix, which is returned in the array A.
Parameters:
IMAT
IMAT is INTEGER
An integer key describing which matrix to generate for this
path.
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A will be upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies whether the matrix or its transpose will be used.
= 'N': No transpose
= 'T': Transpose
= 'C': Conjugate transpose (= Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
ISEED
ISEED is INTEGER array, dimension (4)
The seed vector for the random number generator (used in
SLATMS). Modified on exit.
N
N is INTEGER
The order of the matrix to be generated.
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.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
B
B is REAL array, dimension (N)
The right hand side vector, if IMAT > 10.
WORK
WORK is REAL array, dimension (3*N)
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -k, the k-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SLAVSP performs one of the matrix-vector operations
x := A*x or x := A'*x,
where x is an N element vector and A is one of the factors
from the block U*D*U' or L*D*L' factorization computed by 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' )
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the factor stored in A is upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation to be performed:
= 'N': x := A*x
= 'T': x := A'*x
= 'C': x := A'*x
DIAG
DIAG is CHARACTER*1
Specifies whether or not the diagonal blocks are unit
matrices. If the diagonal blocks are assumed to be unit,
then A = U or A = L, otherwise A = U*D or A = L*D.
= 'U': Diagonal blocks are assumed to be unit matrices.
= 'N': Diagonal blocks are assumed to be non-unit matrices.
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of vectors
x to be multiplied by A. NRHS >= 0.
A
A is 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.
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from SSPTRF.
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.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -k, the k-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SLAVSY performs one of the matrix-vector operations
x := A*x or x := A'*x,
where x is an N element vector and A is one of the factors
from the block U*D*U' or L*D*L' factorization computed by 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')
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the factor stored in A is upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation to be performed:
= 'N': x := A*x
= 'T': x := A'*x
= 'C': x := A'*x
DIAG
DIAG is CHARACTER*1
Specifies whether or not the diagonal blocks are unit
matrices. If the diagonal blocks are assumed to be unit,
then A = U or A = L, otherwise A = U*D or A = L*D.
= 'U': Diagonal blocks are assumed to be unit matrices.
= 'N': Diagonal blocks are assumed to be non-unit matrices.
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of vectors
x to be multiplied by A. NRHS >= 0.
A
A is 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.
Stored as a 2-D triangular matrix.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
Details of the interchanges and the block structure of D,
as determined by SSYTRF.
If UPLO = 'U':
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
(If IPIV( k ) = k, no interchange was done).
If IPIV(k) = IPIV(k-1) < 0, then rows and
columns k-1 and -IPIV(k) were interchanged,
D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
If UPLO = 'L':
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
(If IPIV( k ) = k, no interchange was done).
If IPIV(k) = IPIV(k+1) < 0, then rows and
columns k+1 and -IPIV(k) were interchanged,
D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
B
B is REAL array, dimension (LDB,NRHS)
On entry, B contains NRHS vectors of length N.
On exit, B is overwritten with the product A * B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -k, the k-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine slavsy_rook (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_ROOK
Purpose:
SLAVSY_ROOK performs one of the matrix-vector operations
x := A*x or x := A'*x,
where x is an N element vector and A is one of the factors
from the block U*D*U' or L*D*L' factorization computed by SSYTRF_ROOK.
If TRANS = 'N', multiplies by U or U * D (or L or L * D)
If TRANS = 'T', multiplies by U' or D * U' (or L' or D * L')
If TRANS = 'C', multiplies by U' or D * U' (or L' or D * L')
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the factor stored in A is upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation to be performed:
= 'N': x := A*x
= 'T': x := A'*x
= 'C': x := A'*x
DIAG
DIAG is CHARACTER*1
Specifies whether or not the diagonal blocks are unit
matrices. If the diagonal blocks are assumed to be unit,
then A = U or A = L, otherwise A = U*D or A = L*D.
= 'U': Diagonal blocks are assumed to be unit matrices.
= 'N': Diagonal blocks are assumed to be non-unit matrices.
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of vectors
x to be multiplied by A. NRHS >= 0.
A
A is 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_ROOK.
Stored as a 2-D triangular matrix.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
Details of the interchanges and the block structure of D,
as determined by SSYTRF_ROOK.
If UPLO = 'U':
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
(If IPIV( k ) = k, no interchange was done).
If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and
columns k and -IPIV(k) were interchanged and rows and
columns k-1 and -IPIV(k-1) were inerchaged,
D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
If UPLO = 'L':
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
(If IPIV( k ) = k, no interchange was done).
If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and
columns k and -IPIV(k) were interchanged and rows and
columns k+1 and -IPIV(k+1) were inerchaged,
D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
B
B is REAL array, dimension (LDB,NRHS)
On entry, B contains NRHS vectors of length N.
On exit, B is overwritten with the product A * B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -k, the k-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine 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
Purpose:
SLQT01 tests SGELQF, which computes the LQ factorization of an m-by-n
matrix A, and partially tests SORGLQ which forms the n-by-n
orthogonal matrix Q.
SLQT01 compares L with A*Q', and checks that Q is orthogonal.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The m-by-n matrix A.
AF
AF is REAL array, dimension (LDA,N)
Details of the LQ factorization of A, as returned by SGELQF.
See SGELQF for further details.
Q
Q is REAL array, dimension (LDA,N)
The n-by-n orthogonal matrix Q.
L
L is REAL array, dimension (LDA,max(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and L.
LDA >= max(M,N).
TAU
TAU is REAL array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by SGELQF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is REAL array, dimension (max(M,N))
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SLQT02 tests SORGLQ, which generates an m-by-n matrix Q with
orthonornmal rows that is defined as the product of k elementary
reflectors.
Given the LQ factorization of an m-by-n matrix A, 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.
Parameters:
M
M is INTEGER
The number of rows of the matrix Q to be generated. M >= 0.
N
N is INTEGER
The number of columns of the matrix Q to be generated.
N >= M >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
matrix Q. M >= K >= 0.
A
A is REAL array, dimension (LDA,N)
The m-by-n matrix A which was factorized by SLQT01.
AF
AF is REAL array, dimension (LDA,N)
Details of the LQ factorization of A, as returned by SGELQF.
See SGELQF for further details.
Q
Q is REAL array, dimension (LDA,N)
L
L is REAL array, dimension (LDA,M)
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and L. LDA >= N.
TAU
TAU is REAL array, dimension (M)
The scalar factors of the elementary reflectors corresponding
to the LQ factorization in AF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is REAL array, dimension (M)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
M
M is INTEGER
The number of rows or columns of the matrix C; C is n-by-m if
Q is applied from the left, or m-by-n if Q is applied from
the right. M >= 0.
N
N is INTEGER
The order of the orthogonal matrix Q. N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
orthogonal matrix Q. N >= K >= 0.
AF
AF is REAL array, dimension (LDA,N)
Details of the LQ factorization of an m-by-n matrix, as
returned by SGELQF. See SGELQF for further details.
C
C is REAL array, dimension (LDA,N)
CC
CC is REAL array, dimension (LDA,N)
Q
Q is REAL array, dimension (LDA,N)
LDA
LDA is INTEGER
The leading dimension of the arrays AF, C, CC, and Q.
TAU
TAU is REAL array, dimension (min(M,N))
The scalar factors of the elementary reflectors corresponding
to the LQ factorization in AF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of WORK. LWORK must be at least M, and should be
M*NB, where NB is the blocksize for this environment.
RWORK
RWORK is REAL array, dimension (M)
RESULT
RESULT is REAL array, dimension (4)
The test ratios compare two techniques for multiplying a
random matrix C by an n-by-n orthogonal matrix Q.
RESULT(1) = norm( Q*C - Q*C ) / ( N * norm(C) * EPS )
RESULT(2) = norm( C*Q - C*Q ) / ( N * norm(C) * EPS )
RESULT(3) = norm( Q'*C - Q'*C )/ ( N * norm(C) * EPS )
RESULT(4) = norm( C*Q' - C*Q' )/ ( N * norm(C) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
KD
KD is INTEGER
The number of super-diagonals of the matrix A if UPLO = 'U',
or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
A
A is 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.
LDA
LDA is INTEGER.
The leading dimension of the array A. LDA >= max(1,KD+1).
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.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC.
LDAFAC >= max(1,KD+1).
RWORK
RWORK is REAL array, dimension (N)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
KD
KD is INTEGER
The number of super-diagonals of the matrix A if UPLO = 'U',
or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides. NRHS >= 0.
A
A is 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.
LDA
LDA is INTEGER.
The leading dimension of the array A. LDA >= max(1,KD+1).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is 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.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RWORK
RWORK is REAL array, dimension (N)
RESID
RESID is REAL
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored.
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
KD
KD is INTEGER
The number of super-diagonals of the matrix A if UPLO = 'U',
or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
AB
AB is 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 j-th column
of A is stored in the j-th column of the array AB as follows:
if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is REAL array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is 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.
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).
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 + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine spot01 (character UPLO, integer N, real, dimension( lda, * ) A, integer LDA, real, dimension(
ldafac, * ) AFAC, integer LDAFAC, real, dimension( * ) RWORK, real RESID)
SPOT01
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The original symmetric matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
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).
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,N).
RWORK
RWORK is REAL array, dimension (N)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is REAL array, dimension (LDA,N)
The original symmetric matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is 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.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RWORK
RWORK is REAL array, dimension (N)
RESID
RESID is REAL
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The original symmetric matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
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.
LDAINV
LDAINV is INTEGER
The leading dimension of the array AINV. LDAINV >= max(1,N).
WORK
WORK is REAL array, dimension (LDWORK,N)
LDWORK
LDWORK is INTEGER
The leading dimension of the array WORK. LDWORK >= max(1,N).
RWORK
RWORK is REAL array, dimension (N)
RCOND
RCOND is REAL
The reciprocal of the condition number of A, computed as
( 1/norm(A) ) / norm(AINV).
RESID
RESID is REAL
norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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 )
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored.
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
A
A is 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.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is REAL array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is 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.
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).
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 + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine sppt01 (character UPLO, integer N, real, dimension( * ) A, real, dimension( * ) AFAC, real,
dimension( * ) RWORK, real RESID)
SPPT01
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is REAL array, dimension (N*(N+1)/2)
The original symmetric matrix A, stored as a packed
triangular matrix.
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).
RWORK
RWORK is REAL array, dimension (N)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is REAL array, dimension (N*(N+1)/2)
The original symmetric matrix A, stored as a packed
triangular matrix.
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is 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.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RWORK
RWORK is REAL array, dimension (N)
RESID
RESID is REAL
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is REAL array, dimension (N*(N+1)/2)
The original symmetric matrix A, stored as a packed
triangular matrix.
AINV
AINV is REAL array, dimension (N*(N+1)/2)
The (symmetric) inverse of the matrix A, stored as a packed
triangular matrix.
WORK
WORK is REAL array, dimension (LDWORK,N)
LDWORK
LDWORK is INTEGER
The leading dimension of the array WORK. LDWORK >= max(1,N).
RWORK
RWORK is REAL array, dimension (N)
RCOND
RCOND is REAL
The reciprocal of the condition number of A, computed as
( 1/norm(A) ) / norm(AINV).
RESID
RESID is REAL
norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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 )
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored.
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
AP
AP is REAL array, dimension (N*(N+1)/2)
The upper or lower triangle of the symmetric matrix A, packed
columnwise in a linear array. The j-th column of A is stored
in the array AP as follows:
if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is REAL array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is 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.
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).
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 + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The original symmetric matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
AFAC
AFAC is REAL array, dimension (LDAFAC,N)
The factor L or U from the L*L' or U'*U
factorization of A.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,N).
PERM
PERM is 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)
LDPERM
LDPERM is INTEGER
The leading dimension of the array PERM.
LDAPERM >= max(1,N).
PIV
PIV is INTEGER array, dimension (N)
PIV is such that the nonzero entries are
P( PIV( K ), K ) = 1.
RWORK
RWORK is REAL array, dimension (N)
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 )
RANK
RANK is INTEGER
number of nonzero singular values of A.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine sptt01 (integer N, real, dimension( * ) D, real, dimension( * ) E, real, dimension( * ) DF, real,
dimension( * ) EF, real, dimension( * ) WORK, real RESID)
SPTT01
Purpose:
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.
Parameters:
N
N is INTEGTER
The order of the matrix A.
D
D is REAL array, dimension (N)
The n diagonal elements of the tridiagonal matrix A.
E
E is REAL array, dimension (N-1)
The (n-1) subdiagonal elements of the tridiagonal matrix A.
DF
DF is REAL array, dimension (N)
The n diagonal elements of the factor L from the L*D*L'
factorization of A.
EF
EF is REAL array, dimension (N-1)
The (n-1) subdiagonal elements of the factor L from the
L*D*L' factorization of A.
WORK
WORK is REAL array, dimension (2*N)
RESID
RESID is REAL
norm(L*D*L' - A) / (n * norm(A) * EPS)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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.
Parameters:
N
N is INTEGTER
The order of the matrix A.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices B and X. NRHS >= 0.
D
D is REAL array, dimension (N)
The n diagonal elements of the tridiagonal matrix A.
E
E is REAL array, dimension (N-1)
The (n-1) subdiagonal elements of the tridiagonal matrix A.
X
X is REAL array, dimension (LDX,NRHS)
The n by nrhs matrix of solution vectors X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is 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.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RESID
RESID is REAL
norm(B - A*X) / (norm(A) * norm(X) * EPS)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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
Parameters:
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
D
D is REAL array, dimension (N)
The n diagonal elements of the tridiagonal matrix A.
E
E is REAL array, dimension (N-1)
The (n-1) subdiagonal elements of the tridiagonal matrix A.
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is REAL array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is 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.
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).
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 + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SQLT01 tests SGEQLF, which computes the QL factorization of an m-by-n
matrix A, and partially tests SORGQL which forms the m-by-m
orthogonal matrix Q.
SQLT01 compares L with Q'*A, and checks that Q is orthogonal.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The m-by-n matrix A.
AF
AF is REAL array, dimension (LDA,N)
Details of the QL factorization of A, as returned by SGEQLF.
See SGEQLF for further details.
Q
Q is REAL array, dimension (LDA,M)
The m-by-m orthogonal matrix Q.
L
L is REAL array, dimension (LDA,max(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and R.
LDA >= max(M,N).
TAU
TAU is REAL array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by SGEQLF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is REAL array, dimension (M)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SQLT02 tests SORGQL, which generates an m-by-n matrix Q with
orthonornmal columns that is defined as the product of k elementary
reflectors.
Given the QL factorization of an m-by-n matrix A, SQLT02 generates
the orthogonal matrix Q defined by the factorization of the last k
columns of A; it compares L(m-n+1:m,n-k+1:n) with
Q(1:m,m-n+1:m)'*A(1:m,n-k+1:n), and checks that the columns of Q are
orthonormal.
Parameters:
M
M is INTEGER
The number of rows of the matrix Q to be generated. M >= 0.
N
N is INTEGER
The number of columns of the matrix Q to be generated.
M >= N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
matrix Q. N >= K >= 0.
A
A is REAL array, dimension (LDA,N)
The m-by-n matrix A which was factorized by SQLT01.
AF
AF is REAL array, dimension (LDA,N)
Details of the QL factorization of A, as returned by SGEQLF.
See SGEQLF for further details.
Q
Q is REAL array, dimension (LDA,N)
L
L is REAL array, dimension (LDA,N)
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and L. LDA >= M.
TAU
TAU is REAL array, dimension (N)
The scalar factors of the elementary reflectors corresponding
to the QL factorization in AF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is REAL array, dimension (M)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
M
M is INTEGER
The order of the orthogonal matrix Q. M >= 0.
N
N is INTEGER
The number of rows or columns of the matrix C; C is m-by-n if
Q is applied from the left, or n-by-m if Q is applied from
the right. N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
orthogonal matrix Q. M >= K >= 0.
AF
AF is REAL array, dimension (LDA,N)
Details of the QL factorization of an m-by-n matrix, as
returned by SGEQLF. See SGEQLF for further details.
C
C is REAL array, dimension (LDA,N)
CC
CC is REAL array, dimension (LDA,N)
Q
Q is REAL array, dimension (LDA,M)
LDA
LDA is INTEGER
The leading dimension of the arrays AF, C, CC, and Q.
TAU
TAU is REAL array, dimension (min(M,N))
The scalar factors of the elementary reflectors corresponding
to the QL factorization in AF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of WORK. LWORK must be at least M, and should be
M*NB, where NB is the blocksize for this environment.
RWORK
RWORK is REAL array, dimension (M)
RESULT
RESULT is REAL array, dimension (4)
The test ratios compare two techniques for multiplying a
random matrix C by an m-by-m orthogonal matrix Q.
RESULT(1) = norm( Q*C - Q*C ) / ( M * norm(C) * EPS )
RESULT(2) = norm( C*Q - C*Q ) / ( M * norm(C) * EPS )
RESULT(3) = norm( Q'*C - Q'*C )/ ( M * norm(C) * EPS )
RESULT(4) = norm( C*Q' - C*Q' )/ ( M * norm(C) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SQPT01 tests the QR-factorization with pivoting of a matrix A. The
array AF contains the (possibly partial) QR-factorization of A, where
the upper triangle of AF(1:k,1:k) is a partial triangular factor,
the entries below the diagonal in the first k columns are the
Householder vectors, and the rest of AF contains a partially updated
matrix.
This function returns ||A*P - Q*R||/(||norm(A)||*eps*M)
Parameters:
M
M is INTEGER
The number of rows of the matrices A and AF.
N
N is INTEGER
The number of columns of the matrices A and AF.
K
K is INTEGER
The number of columns of AF that have been reduced
to upper triangular form.
A
A is REAL array, dimension (LDA, N)
The original matrix A.
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.
LDA
LDA is INTEGER
The leading dimension of the arrays A and AF.
TAU
TAU is REAL array, dimension (K)
Details of the Householder transformations as returned by
SGEQPF.
JPVT
JPVT is INTEGER array, dimension (N)
Pivot information as returned by SGEQPF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK >= M*N+N.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
SQRT01 tests SGEQRF, which computes the QR factorization of an m-by-n
matrix A, and partially tests SORGQR which forms the m-by-m
orthogonal matrix Q.
SQRT01 compares R with Q'*A, and checks that Q is orthogonal.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The m-by-n matrix A.
AF
AF is REAL array, dimension (LDA,N)
Details of the QR factorization of A, as returned by SGEQRF.
See SGEQRF for further details.
Q
Q is REAL array, dimension (LDA,M)
The m-by-m orthogonal matrix Q.
R
R is REAL array, dimension (LDA,max(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and R.
LDA >= max(M,N).
TAU
TAU is REAL array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by SGEQRF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is REAL array, dimension (M)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SQRT01P tests SGEQRFP, which computes the QR factorization of an m-by-n
matrix A, and partially tests SORGQR which forms the m-by-m
orthogonal matrix Q.
SQRT01P compares R with Q'*A, and checks that Q is orthogonal.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The m-by-n matrix A.
AF
AF is REAL array, dimension (LDA,N)
Details of the QR factorization of A, as returned by SGEQRFP.
See SGEQRFP for further details.
Q
Q is REAL array, dimension (LDA,M)
The m-by-m orthogonal matrix Q.
R
R is REAL array, dimension (LDA,max(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and R.
LDA >= max(M,N).
TAU
TAU is REAL array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by SGEQRFP.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is REAL array, dimension (M)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SQRT02 tests SORGQR, which generates an m-by-n matrix Q with
orthonornmal columns that is defined as the product of k elementary
reflectors.
Given the QR factorization of an m-by-n matrix A, 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.
Parameters:
M
M is INTEGER
The number of rows of the matrix Q to be generated. M >= 0.
N
N is INTEGER
The number of columns of the matrix Q to be generated.
M >= N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
matrix Q. N >= K >= 0.
A
A is REAL array, dimension (LDA,N)
The m-by-n matrix A which was factorized by SQRT01.
AF
AF is REAL array, dimension (LDA,N)
Details of the QR factorization of A, as returned by SGEQRF.
See SGEQRF for further details.
Q
Q is REAL array, dimension (LDA,N)
R
R is REAL array, dimension (LDA,N)
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and R. LDA >= M.
TAU
TAU is REAL array, dimension (N)
The scalar factors of the elementary reflectors corresponding
to the QR factorization in AF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is REAL array, dimension (M)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
M
M is INTEGER
The order of the orthogonal matrix Q. M >= 0.
N
N is INTEGER
The number of rows or columns of the matrix C; C is m-by-n if
Q is applied from the left, or n-by-m if Q is applied from
the right. N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
orthogonal matrix Q. M >= K >= 0.
AF
AF is REAL array, dimension (LDA,N)
Details of the QR factorization of an m-by-n matrix, as
returned by SGEQRF. See SGEQRF for further details.
C
C is REAL array, dimension (LDA,N)
CC
CC is REAL array, dimension (LDA,N)
Q
Q is REAL array, dimension (LDA,M)
LDA
LDA is INTEGER
The leading dimension of the arrays AF, C, CC, and Q.
TAU
TAU is REAL array, dimension (min(M,N))
The scalar factors of the elementary reflectors corresponding
to the QR factorization in AF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of WORK. LWORK must be at least M, and should be
M*NB, where NB is the blocksize for this environment.
RWORK
RWORK is REAL array, dimension (M)
RESULT
RESULT is REAL array, dimension (4)
The test ratios compare two techniques for multiplying a
random matrix C by an m-by-m orthogonal matrix Q.
RESULT(1) = norm( Q*C - Q*C ) / ( M * norm(C) * EPS )
RESULT(2) = norm( C*Q - C*Q ) / ( M * norm(C) * EPS )
RESULT(3) = norm( Q'*C - Q'*C )/ ( M * norm(C) * EPS )
RESULT(4) = norm( C*Q' - C*Q' )/ ( M * norm(C) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine sqrt04 (integer M, integer N, integer NB, real, dimension(6) RESULT)
SQRT04
Purpose:
SQRT04 tests SGEQRT and SGEMQRT.
Parameters:
M
M is INTEGER
Number of rows in test matrix.
N
N is INTEGER
Number of columns in test matrix.
NB
NB is INTEGER
Block size of test matrix. NB <= Min(M,N).
RESULT
RESULT is 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 |
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
subroutine sqrt05 (integer M, integer N, integer L, integer NB, real, dimension(6) RESULT)
SQRT05
Purpose:
SQRT05 tests STPQRT and STPMQRT.
Parameters:
M
M is INTEGER
Number of rows in lower part of the test matrix.
N
N is INTEGER
Number of columns in test matrix.
L
L is INTEGER
The number of rows of the upper trapezoidal part the
lower test matrix. 0 <= L <= M.
NB
NB is INTEGER
Block size of test matrix. NB <= N.
RESULT
RESULT is 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 |
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
real function sqrt11 (integer M, integer K, real, dimension( lda, * ) A, integer LDA, real, dimension( * )
TAU, real, dimension( lwork ) WORK, integer LWORK)
SQRT11
Purpose:
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 m-vector of the form
[ 0 ... 0 1 x(k) ]', where x(k) is a vector of length m-k stored
in A(k+1:m,k).
Parameters:
M
M is INTEGER
The number of rows of the matrix A.
K
K is INTEGER
The number of columns of A whose subdiagonal entries
contain information about orthogonal transformations.
A
A is REAL array, dimension (LDA,K)
The (possibly partial) output of a QR reduction routine.
LDA
LDA is INTEGER
The leading dimension of the array A.
TAU
TAU is REAL array, dimension (K)
The scaling factors tau for the elementary transformations as
computed by the QR factorization routine.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK >= M*M + M.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
real function sqrt12 (integer M, integer N, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) S,
real, dimension( lwork ) WORK, integer LWORK)
SQRT12
Purpose:
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))
Parameters:
M
M is INTEGER
The number of rows of the matrix A.
N
N is INTEGER
The number of columns of the matrix A.
A
A is REAL array, dimension (LDA,N)
The M-by-N matrix A. Only the upper trapezoid is referenced.
LDA
LDA is INTEGER
The leading dimension of the array A.
S
S is REAL array, dimension (min(M,N))
The singular values of the matrix A.
WORK
WORK is REAL array, dimension (LWORK)
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).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine sqrt13 (integer SCALE, integer M, integer N, real, dimension( lda, * ) A, integer LDA, real NORMA,
integer, dimension( 4 ) ISEED)
SQRT13
Purpose:
SQRT13 generates a full-rank matrix that may be scaled to have large
or small norm.
Parameters:
SCALE
SCALE is INTEGER
SCALE = 1: normally scaled matrix
SCALE = 2: matrix scaled up
SCALE = 3: matrix scaled down
M
M is INTEGER
The number of rows of the matrix A.
N
N is INTEGER
The number of columns of A.
A
A is REAL array, dimension (LDA,N)
The M-by-N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A.
NORMA
NORMA is REAL
The one-norm of A.
ISEED
ISEED is integer array, dimension (4)
Seed for random number generator
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
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'.
M
M is INTEGER
The number of rows of the matrix A.
N
N is INTEGER
The number of columns of the matrix A.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of X.
A
A is REAL array, dimension (LDA,N)
The M-by-N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A.
X
X is REAL array, dimension (LDX,NRHS)
If TRANS = 'N', the N-by-NRHS matrix X.
IF TRANS = 'T', the M-by-NRHS matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X.
WORK
WORK is REAL array dimension (LWORK)
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).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SQRT15 generates a matrix with full or deficient rank and of various
norms.
Parameters:
SCALE
SCALE is INTEGER
SCALE = 1: normally scaled matrix
SCALE = 2: matrix scaled up
SCALE = 3: matrix scaled down
RKSEL
RKSEL is INTEGER
RKSEL = 1: full rank matrix
RKSEL = 2: rank-deficient matrix
M
M is INTEGER
The number of rows of the matrix A.
N
N is INTEGER
The number of columns of A.
NRHS
NRHS is INTEGER
The number of columns of B.
A
A is REAL array, dimension (LDA,N)
The M-by-N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A.
B
B is REAL array, dimension (LDB, NRHS)
A matrix that is in the range space of matrix A.
LDB
LDB is INTEGER
The leading dimension of the array B.
S
S is REAL array, dimension MIN(M,N)
Singular values of A.
RANK
RANK is INTEGER
number of nonzero singular values of A.
NORMA
NORMA is REAL
one-norm of A.
NORMB
NORMB is REAL
one-norm of B.
ISEED
ISEED is integer array, dimension (4)
seed for random number generator.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
length of work space required.
LWORK >= MAX(M+MIN(M,N),NRHS*MIN(M,N),2*N+M)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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.
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations:
= 'N': A *x = b
= 'T': A'*x = b, where A' is the transpose of A
= 'C': A'*x = b, where A' is the transpose of A
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is REAL array, dimension (LDA,N)
The original M x N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,M).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
B
B is 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.
LDB
LDB is INTEGER
The leading dimension of the array B. IF TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
RWORK
RWORK is REAL array, dimension (M)
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 ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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 (zero-residual problem)
alpha = ||R|| if IRESID = 2 (otherwise).
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies whether or not the transpose of A is used.
= 'N': No transpose, op(A) = A.
= 'T': Transpose, op(A) = A'.
IRESID
IRESID is INTEGER
IRESID = 1 indicates zero-residual problem.
IRESID = 2 indicates non-zero residual.
M
M is INTEGER
The number of rows of the matrix A.
If TRANS = 'N', the number of rows of the matrix B.
If TRANS = 'T', the number of rows of the matrix X.
N
N is INTEGER
The number of columns of the matrix A.
If TRANS = 'N', the number of rows of the matrix X.
If TRANS = 'T', the number of rows of the matrix B.
NRHS
NRHS is INTEGER
The number of columns of the matrices X and B.
A
A is REAL array, dimension (LDA,N)
The m-by-n matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= M.
X
X is REAL array, dimension (LDX,NRHS)
If TRANS = 'N', the n-by-nrhs matrix X.
If TRANS = 'T', the m-by-nrhs matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X.
If TRANS = 'N', LDX >= N.
If TRANS = 'T', LDX >= M.
B
B is REAL array, dimension (LDB,NRHS)
If TRANS = 'N', the m-by-nrhs matrix B.
If TRANS = 'T', the n-by-nrhs matrix B.
LDB
LDB is INTEGER
The leading dimension of the array B.
If TRANS = 'N', LDB >= M.
If TRANS = 'T', LDB >= N.
C
C is REAL array, dimension (LDB,NRHS)
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK >= NRHS*(M+N).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine 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
Purpose:
SRQT01 tests SGERQF, which computes the RQ factorization of an m-by-n
matrix A, and partially tests SORGRQ which forms the n-by-n
orthogonal matrix Q.
SRQT01 compares R with A*Q', and checks that Q is orthogonal.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The m-by-n matrix A.
AF
AF is REAL array, dimension (LDA,N)
Details of the RQ factorization of A, as returned by SGERQF.
See SGERQF for further details.
Q
Q is REAL array, dimension (LDA,N)
The n-by-n orthogonal matrix Q.
R
R is REAL array, dimension (LDA,max(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and L.
LDA >= max(M,N).
TAU
TAU is REAL array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by SGERQF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is REAL array, dimension (max(M,N))
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SRQT02 tests SORGRQ, which generates an m-by-n matrix Q with
orthonornmal rows that is defined as the product of k elementary
reflectors.
Given the RQ factorization of an m-by-n matrix A, SRQT02 generates
the orthogonal matrix Q defined by the factorization of the last k
rows of A; it compares R(m-k+1:m,n-m+1:n) with
A(m-k+1:m,1:n)*Q(n-m+1:n,1:n)', and checks that the rows of Q are
orthonormal.
Parameters:
M
M is INTEGER
The number of rows of the matrix Q to be generated. M >= 0.
N
N is INTEGER
The number of columns of the matrix Q to be generated.
N >= M >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
matrix Q. M >= K >= 0.
A
A is REAL array, dimension (LDA,N)
The m-by-n matrix A which was factorized by SRQT01.
AF
AF is REAL array, dimension (LDA,N)
Details of the RQ factorization of A, as returned by SGERQF.
See SGERQF for further details.
Q
Q is REAL array, dimension (LDA,N)
R
R is REAL array, dimension (LDA,M)
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and L. LDA >= N.
TAU
TAU is REAL array, dimension (M)
The scalar factors of the elementary reflectors corresponding
to the RQ factorization in AF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is REAL array, dimension (M)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
M
M is INTEGER
The number of rows or columns of the matrix C; C is n-by-m if
Q is applied from the left, or m-by-n if Q is applied from
the right. M >= 0.
N
N is INTEGER
The order of the orthogonal matrix Q. N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
orthogonal matrix Q. N >= K >= 0.
AF
AF is REAL array, dimension (LDA,N)
Details of the RQ factorization of an m-by-n matrix, as
returned by SGERQF. See SGERQF for further details.
C
C is REAL array, dimension (LDA,N)
CC
CC is REAL array, dimension (LDA,N)
Q
Q is REAL array, dimension (LDA,N)
LDA
LDA is INTEGER
The leading dimension of the arrays AF, C, CC, and Q.
TAU
TAU is REAL array, dimension (min(M,N))
The scalar factors of the elementary reflectors corresponding
to the RQ factorization in AF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of WORK. LWORK must be at least M, and should be
M*NB, where NB is the blocksize for this environment.
RWORK
RWORK is REAL array, dimension (M)
RESULT
RESULT is REAL array, dimension (4)
The test ratios compare two techniques for multiplying a
random matrix C by an n-by-n orthogonal matrix Q.
RESULT(1) = norm( Q*C - Q*C ) / ( N * norm(C) * EPS )
RESULT(2) = norm( C*Q - C*Q ) / ( N * norm(C) * EPS )
RESULT(3) = norm( Q'*C - Q'*C )/ ( N * norm(C) * EPS )
RESULT(4) = norm( C*Q' - C*Q' )/ ( N * norm(C) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
SRZT01 returns
|| A - R*Q || / ( M * eps * ||A|| )
for an upper trapezoidal A that was factored with STZRZF.
Parameters:
M
M is INTEGER
The number of rows of the matrices A and AF.
N
N is INTEGER
The number of columns of the matrices A and AF.
A
A is REAL array, dimension (LDA,N)
The original upper trapezoidal M by N matrix A.
AF
AF is REAL array, dimension (LDA,N)
The output of STZRZF for input matrix A.
The lower triangle is not referenced.
LDA
LDA is INTEGER
The leading dimension of the arrays A and AF.
TAU
TAU is REAL array, dimension (M)
Details of the Householder transformations as returned by
STZRZF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK >= m*n + m*nb.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
real function srzt02 (integer M, integer N, real, dimension( lda, * ) AF, integer LDA, real, dimension( * )
TAU, real, dimension( lwork ) WORK, integer LWORK)
SRZT02
Purpose:
SRZT02 returns
|| I - Q'*Q || / ( M * eps)
where the matrix Q is defined by the Householder transformations
generated by STZRZF.
Parameters:
M
M is INTEGER
The number of rows of the matrix AF.
N
N is INTEGER
The number of columns of the matrix AF.
AF
AF is REAL array, dimension (LDA,N)
The output of STZRZF.
LDA
LDA is INTEGER
The leading dimension of the array AF.
TAU
TAU is REAL array, dimension (M)
Details of the Householder transformations as returned by
STZRZF.
WORK
WORK is REAL array, dimension (LWORK)
LWORK
LWORK is INTEGER
length of WORK array. LWORK >= N*N+N*NB.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is REAL array, dimension (N*(N+1)/2)
The original symmetric matrix A, stored as a packed
triangular matrix.
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.
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from SSPTRF.
C
C is REAL array, dimension (LDC,N)
LDC
LDC is INTEGER
The leading dimension of the array C. LDC >= max(1,N).
RWORK
RWORK is REAL array, dimension (N)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The original symmetric matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
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.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from SSYTRF.
C
C is REAL array, dimension (LDC,N)
LDC
LDC is INTEGER
The leading dimension of the array C. LDC >= max(1,N).
RWORK
RWORK is REAL array, dimension (N)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine ssyt01_rook (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_ROOK
Purpose:
SSYT01_ROOK 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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is REAL array, dimension (LDA,N)
The original symmetric matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
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_ROOK.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from SSYTRF_ROOK.
C
C is REAL array, dimension (LDC,N)
LDC
LDC is INTEGER
The leading dimension of the array C. LDC >= max(1,N).
RWORK
RWORK is REAL array, dimension (N)
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 )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = b (No transpose)
= 'T': A'*x = b (Transpose)
= 'C': A'*x = b (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
KD
KD is INTEGER
The number of superdiagonals or subdiagonals of the
triangular band matrix A. KD >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
AB
AB is REAL array, dimension (LDAB,N)
The upper or lower triangular band matrix A, stored in the
first kd+1 rows of the array. The j-th column of A is stored
in the j-th column of the array AB as follows:
if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is REAL array, dimension (N)
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 ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = b (No transpose)
= 'T': A'*x = b (Transpose)
= 'C': A'*x = b (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
KD
KD is INTEGER
The number of superdiagonals or subdiagonals of the
triangular band matrix A. KD >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
AB
AB is REAL array, dimension (LDAB,N)
The upper or lower triangular band matrix A, stored in the
first kd+1 rows of the array. The j-th column of A is stored
in the j-th column of the array AB as follows:
if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
SCALE
SCALE is REAL
The scaling factor s used in solving the triangular system.
CNORM
CNORM is REAL array, dimension (N)
The 1-norms of the columns of A, not counting the diagonal.
TSCAL
TSCAL is REAL
The scaling factor used in computing the 1-norms in CNORM.
CNORM actually contains the column norms of TSCAL*A.
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is REAL array, dimension (N)
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 ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A'* X = B (Transpose)
= 'C': A'* X = B (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
KD
KD is INTEGER
The number of super-diagonals of the matrix A if UPLO = 'U',
or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
AB
AB is REAL array, dimension (LDAB,N)
The upper or lower triangular band matrix A, stored in the
first kd+1 rows of the array. The j-th column of A is stored
in the j-th column of the array AB as follows:
if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
If DIAG = 'U', the diagonal elements of A are not referenced
and are assumed to be 1.
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is REAL array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is 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.
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).
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 + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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 non-zero to decide if
underflow in the estimate is justified.
Parameters:
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)) ).
RCONDC
RCONDC is REAL
The estimate of the reciprocal condition number computed by
STBCON.
UPLO
UPLO is CHARACTER
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
DIAG
DIAG is CHARACTER
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
KD
KD is INTEGER
The number of superdiagonals or subdiagonals of the
triangular band matrix A. KD >= 0.
AB
AB is REAL array, dimension (LDAB,N)
The upper or lower triangular band matrix A, stored in the
first kd+1 rows of the array. The j-th column of A is stored
in the j-th column of the array AB as follows:
if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
WORK
WORK is REAL array, dimension (N)
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.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine stpt01 (character UPLO, character DIAG, integer N, real, dimension( * ) AP, real, dimension( * )
AINVP, real RCOND, real, dimension( * ) WORK, real RESID)
STPT01
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
AP
AP is REAL array, dimension (N*(N+1)/2)
The original upper or lower triangular matrix A, packed
columnwise in a linear array. The j-th column of A is stored
in the array AP as follows:
if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
if UPLO = 'L',
AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.
AINVP
AINVP is 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.
RCOND
RCOND is REAL
The reciprocal condition number of A, computed as
1/(norm(A) * norm(AINV)).
WORK
WORK is REAL array, dimension (N)
RESID
RESID is REAL
norm(A*AINV - I) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = b (No transpose)
= 'T': A'*x = b (Transpose)
= 'C': A'*x = b (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
AP
AP is REAL array, dimension (N*(N+1)/2)
The upper or lower triangular matrix A, packed columnwise in
a linear array. The j-th column of A is stored in the array
AP as follows:
if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
if UPLO = 'L',
AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is REAL array, dimension (N)
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 ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = s*b (No transpose)
= 'T': A'*x = s*b (Transpose)
= 'C': A'*x = s*b (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
AP
AP is REAL array, dimension (N*(N+1)/2)
The upper or lower triangular matrix A, packed columnwise in
a linear array. The j-th column of A is stored in the array
AP as follows:
if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
if UPLO = 'L',
AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.
SCALE
SCALE is REAL
The scaling factor s used in solving the triangular system.
CNORM
CNORM is REAL array, dimension (N)
The 1-norms of the columns of A, not counting the diagonal.
TSCAL
TSCAL is REAL
The scaling factor used in computing the 1-norms in CNORM.
CNORM actually contains the column norms of TSCAL*A.
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is REAL array, dimension (N)
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 ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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 )
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A'* X = B (Transpose)
= 'C': A'* X = B (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
AP
AP is REAL array, dimension (N*(N+1)/2)
The upper or lower triangular matrix A, packed columnwise in
a linear array. The j-th column of A is stored in the array
AP as follows:
if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
If DIAG = 'U', the diagonal elements of A are not referenced
and are assumed to be 1.
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is REAL array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is 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.
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).
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 + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine stpt06 (real RCOND, real RCONDC, character UPLO, character DIAG, integer N, real, dimension( * )
AP, real, dimension( * ) WORK, real RAT)
STPT06
Purpose:
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 non-zero to decide if
underflow in the estimate is justified.
Parameters:
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)) ).
RCONDC
RCONDC is REAL
The estimate of the reciprocal condition number computed by
STPCON.
UPLO
UPLO is CHARACTER
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
DIAG
DIAG is CHARACTER
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
AP
AP is REAL array, dimension (N*(N+1)/2)
The upper or lower triangular matrix A, packed columnwise in
a linear array. The j-th column of A is stored in the array
AP as follows:
if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
if UPLO = 'L',
AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.
WORK
WORK is REAL array, dimension (N)
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.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
A
A is 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.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
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.
LDAINV
LDAINV is INTEGER
The leading dimension of the array AINV. LDAINV >= max(1,N).
RCOND
RCOND is REAL
The reciprocal condition number of A, computed as
1/(norm(A) * norm(AINV)).
WORK
WORK is REAL array, dimension (N)
RESID
RESID is REAL
norm(A*AINV - I) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine 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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = b (No transpose)
= 'T': A'*x = b (Transpose)
= 'C': A'*x = b (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
A
A is 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.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is REAL array, dimension (N)
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 ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
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
Purpose:
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.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = s*b (No transpose)
= 'T': A'*x = s*b (Transpose)
= 'C': A'*x = s*b (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
A
A is 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.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
SCALE
SCALE is REAL
The scaling factor s used in solving the triangular system.
CNORM
CNORM is REAL array, dimension (N)
The 1-norms of the columns of A, not counting the diagonal.
TSCAL
TSCAL is REAL
The scaling factor used in computing the 1-norms in CNORM.
CNORM actually contains the column norms of TSCAL*A.
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is REAL array, dimension (N)
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 ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine strt05 (character UPLO, character TRANS, character DIAG, 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)
STRT05
Purpose:
STRT05 tests the error bounds from iterative refinement for the
computed solution to a system of equations A*X = B, where A is a
triangular n by n matrix.
RESLTS(1) = test of the error bound
= norm(X - XACT) / ( norm(X) * FERR )
A large value is returned if this ratio is not less than one.
RESLTS(2) = residual from the iterative refinement routine
= the maximum of BERR / ( (n+1)*EPS + (*) ), where
(*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A'* X = B (Transpose)
= 'C': A'* X = B (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
A
A is 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.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
B
B is REAL array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is REAL array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is REAL array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is 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.
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).
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 + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine strt06 (real RCOND, real RCONDC, character UPLO, character DIAG, integer N, real, dimension( lda,
* ) A, integer LDA, real, dimension( * ) WORK, real RAT)
STRT06
Purpose:
STRT06 computes a test ratio comparing RCOND (the reciprocal
condition number of a triangular matrix A) and RCONDC, the estimate
computed by STRCON. Information about the triangular matrix A is
used if one estimate is zero and the other is non-zero to decide if
underflow in the estimate is justified.
Parameters:
RCOND
RCOND is 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)) ).
RCONDC
RCONDC is REAL
The estimate of the reciprocal condition number computed by
STRCON.
UPLO
UPLO is CHARACTER
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
DIAG
DIAG is CHARACTER
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
A
A is 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.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
WORK
WORK is REAL array, dimension (N)
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.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
Author
Generated automatically by Doxygen for LAPACK from the source code.
Version 3.6.0 Sun Jan 17 2016 single_lin(3)