man single_lin (3): 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 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 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 is REAL array, dimension (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 is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

AINV

          AINV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 is REAL array, dimension (NMAX*4)

          AF is REAL array, dimension (NMAX*4)

          B is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 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 is REAL array, dimension (NMAX*NMAX)

          AF is REAL array, dimension (NMAX*NMAX)

          AQ is REAL array, dimension (NMAX*NMAX)

          AL is REAL array, dimension (NMAX*NMAX)

          AC is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NRHS)

          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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

AINV

          AINV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

AINV

          AINV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 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 is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 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 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 is REAL array, dimension (NMAX*2)

          D is REAL array, dimension (NMAX*2)

          E is REAL array, dimension (NMAX*2)

          B is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 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 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 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 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 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 is REAL array, dimension (NMAX*NMAX)

          AF is REAL array, dimension (NMAX*NMAX)

          AQ is REAL array, dimension (NMAX*NMAX)

          AL is REAL array, dimension (NMAX*NMAX)

          AC is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NRHS)

          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 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 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 is REAL array, dimension (NMAX*NMAX)

          AF is REAL array, dimension (NMAX*NMAX)

          AQ is REAL array, dimension (NMAX*NMAX)

          AR is REAL array, dimension (NMAX*NMAX)

          AC is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NRHS)

          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 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 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 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 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 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 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 is REAL array, dimension (NMAX*NMAX)

          AF is REAL array, dimension (NMAX*NMAX)

          AQ is REAL array, dimension (NMAX*NMAX)

          AR is REAL array, dimension (NMAX*NMAX)

          AC is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NRHS)

          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 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 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 is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

AINV

          AINV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

AINV

          AINV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 is REAL array, dimension (NMAX*NMAX)

AINV

          AINV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 is REAL array, dimension
                      (NMAX*(NMAX+1)/2)

AINVP

          AINVP is REAL array, dimension
                      (NMAX*(NMAX+1)/2)

          B is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 is REAL array, dimension (NMAX*NMAX)

AINV

          AINV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NSMAX)
          where NSMAX is the largest entry in NSVAL.

          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 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 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 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 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 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 is REAL array, dimension (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 is REAL array, dimension (NMAX*NRHS)

BSAV

          BSAV is REAL array, dimension (NMAX*NRHS)

          X is REAL array, dimension (NMAX*NRHS)

XACT

          XACT is REAL array, dimension (NMAX*NRHS)

          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 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 is REAL array, dimension (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 is REAL array, dimension (NMAX*NRHS)

BSAV

          BSAV is REAL array, dimension (NMAX*NRHS)

          X is REAL array, dimension (NMAX*NRHS)

XACT

          XACT is REAL array, dimension (NMAX*NRHS)

          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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

ASAV

          ASAV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NRHS)

BSAV

          BSAV is REAL array, dimension (NMAX*NRHS)

          X is REAL array, dimension (NMAX*NRHS)

XACT

          XACT is REAL array, dimension (NMAX*NRHS)

          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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

ASAV

          ASAV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NRHS)

BSAV

          BSAV is REAL array, dimension (NMAX*NRHS)

          X is REAL array, dimension (NMAX*NRHS)

XACT

          XACT is REAL array, dimension (NMAX*NRHS)

          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 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 is REAL array, dimension (NMAX*4)

          AF is REAL array, dimension (NMAX*4)

          B is REAL array, dimension (NMAX*NRHS)

          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 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 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 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 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 is REAL array, dimension (MMAX*NSMAX)

          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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

ASAV

          ASAV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NRHS)

BSAV

          BSAV is REAL array, dimension (NMAX*NRHS)

          X is REAL array, dimension (NMAX*NRHS)

XACT

          XACT is REAL array, dimension (NMAX*NRHS)

          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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

ASAV

          ASAV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NRHS)

BSAV

          BSAV is REAL array, dimension (NMAX*NRHS)

          X is REAL array, dimension (NMAX*NRHS)

XACT

          XACT is REAL array, dimension (NMAX*NRHS)

          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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

ASAV

          ASAV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NRHS)

BSAV

          BSAV is REAL array, dimension (NMAX*NRHS)

          X is REAL array, dimension (NMAX*NRHS)

XACT

          XACT is REAL array, dimension (NMAX*NRHS)

          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 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 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 is REAL array, dimension (NMAX*NRHS)

BSAV

          BSAV is REAL array, dimension (NMAX*NRHS)

          X is REAL array, dimension (NMAX*NRHS)

XACT

          XACT is REAL array, dimension (NMAX*NRHS)

          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 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 is REAL array, dimension (NMAX*2)

          D is REAL array, dimension (NMAX*2)

          E is REAL array, dimension (NMAX*2)

          B is REAL array, dimension (NMAX*NRHS)

          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 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 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 conversion routines.

Parameters:

NOUT

          NOUT is INTEGER
                The unit number for output.

          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 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 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 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 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 is REAL array, dimension (LDA,NMAX)

          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 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 is REAL array,
                dimension (LDC,NMAX)

          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 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, conversion 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 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 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 is REAL array, dimension (NMAX*MAXRHS)

BSAV

          BSAV is REAL array, dimension (NMAX*MAXRHS)

XACT

          XACT is REAL array, dimension (NMAX*MAXRHS)

          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 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 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 is REAL array, dimension (NMAX*NRHS)

          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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

AINV

          AINV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NRHS)

          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 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 is REAL array, dimension (NMAX*NMAX)

AFAC

          AFAC is REAL array, dimension (NMAX*NMAX)

AINV

          AINV is REAL array, dimension (NMAX*NMAX)

          B is REAL array, dimension (NMAX*NRHS)

          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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.

          KL is INTEGER
          The number of subdiagonals within the band of A.  KL >= 0.

          KU is INTEGER
          The number of superdiagonals within the band of A.  KU >= 0.

          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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.

          KL is INTEGER
          The number of subdiagonals within the band of A.  KL >= 0.

          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 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 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 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 is INTEGER
          The number of rows of the matrices X, B, and XACT, and the
          order of the matrix A.  N >= 0.

          KL is INTEGER
          The number of subdiagonals within the band of A.  KL >= 0.

          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 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 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 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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          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 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 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 is INTEGER
          The number of rows in A.

          N is INTEGER
          The number of columns in 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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          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 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 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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          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 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 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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          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 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 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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.

          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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          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 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 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 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 is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.

          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 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 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 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 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 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 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 is INTEGTER
          The order of the matrix A.  N >= 0.

          DL is REAL array, dimension (N-1)
          The (n-1) sub-diagonal elements of A.

          D is REAL array, dimension (N)
          The diagonal elements of A.

          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 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 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 is REAL array, dimension (N-1)
          The (n-1) sub-diagonal elements of A.

          D is REAL array, dimension (N)
          The diagonal elements of A.

          DU is REAL array, dimension (N-1)
          The (n-1) super-diagonal elements of A.

          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 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 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 is REAL array, dimension (N-1)
          The (n-1) sub-diagonal elements of A.

          D is REAL array, dimension (N)
          The diagonal elements of A.

          DU is REAL array, dimension (N-1)
          The (n-1) super-diagonal elements of A.

          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 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 is INTEGER
          The dimension of the matrix A.

NRHS

          NRHS is NRHS
          The requested number of right-hand sides.

          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 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 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 is INTEGER
          The length of the vector 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 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 is REAL array, dimension (N)
          The n diagonal elements of the tridiagonal matrix A.

          E is REAL array, dimension (N-1)
          The (n-1) subdiagonal or superdiagonal elements of A.

          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 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 (character3 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 is INTEGER
          The number or rows of the matrix A.  M >= 0.

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.

          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 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 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 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 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 is INTEGER
          The number of rows in the matrix to be generated.

          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 is INTEGER
          The lower band width of the matrix to be generated.

          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 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 is INTEGER
          The lower band width of the matrix to be generated.

          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 is INTEGER
          The order of the matrix to be generated.

          KD is INTEGER
          The number of superdiagonals or subdiagonals of the banded
          triangular matrix A.  KD >= 0.

          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 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 is INTEGER
          The order of the matrix to be generated.

          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 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 is INTEGER
          The order of the matrix to be generated.

          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 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 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 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 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 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 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 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 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 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 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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.

          A is REAL array, dimension (LDA,N)
          The m-by-n matrix A.

          AF is REAL array, dimension (LDA,N)
          Details of the LQ factorization of A, as returned by SGELQF.
          See SGELQF for further details.

          Q is REAL array, dimension (LDA,N)
          The n-by-n orthogonal matrix Q.

          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 is INTEGER
          The number of rows of the matrix Q to be generated.  M >= 0.

          N is INTEGER
          The number of columns of the matrix Q to be generated.
          N >= M >= 0.

          K is INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q. M >= K >= 0.

          A is REAL array, dimension (LDA,N)
          The m-by-n matrix A which was factorized by SLQT01.

          AF is REAL array, dimension (LDA,N)
          Details of the LQ factorization of A, as returned by SGELQF.
          See SGELQF for further details.

          Q is REAL array, dimension (LDA,N)

          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 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 is INTEGER
          The order of the orthogonal matrix Q.  N >= 0.

          K is INTEGER
          The number of elementary reflectors whose product defines the
          orthogonal matrix Q.  N >= K >= 0.

          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 is REAL array, dimension (LDA,N)

          CC is REAL array, dimension (LDA,N)

          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 is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.

          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 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 is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.

          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 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 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 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 is INTEGER
          The number of rows of the matrices X, B, and XACT, and the
          order of the matrix A.  N >= 0.

          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 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 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 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 is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.

          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 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 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 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 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 is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.

          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 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 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 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 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 is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.

          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 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 is REAL array, dimension (N*(N+1)/2)
          The original symmetric matrix A, stored as a packed
          triangular matrix.

          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 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 is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.

          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 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 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 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 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 is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.

          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 is INTEGTER
          The order of the matrix A.

          D is REAL array, dimension (N)
          The n diagonal elements of the tridiagonal matrix A.

          E is REAL array, dimension (N-1)
          The (n-1) subdiagonal elements of the tridiagonal matrix A.

          DF is REAL array, dimension (N)
          The n diagonal elements of the factor L from the L*D*L'
          factorization of A.

          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 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 is REAL array, dimension (N)
          The n diagonal elements of the tridiagonal matrix A.

          E is REAL array, dimension (N-1)
          The (n-1) subdiagonal elements of the tridiagonal matrix A.

          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 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 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 is REAL array, dimension (N)
          The n diagonal elements of the tridiagonal matrix A.

          E is REAL array, dimension (N-1)
          The (n-1) subdiagonal elements of the tridiagonal matrix A.

          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 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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.

          A is REAL array, dimension (LDA,N)
          The m-by-n matrix A.

          AF is REAL array, dimension (LDA,N)
          Details of the QL factorization of A, as returned by SGEQLF.
          See SGEQLF for further details.

          Q is REAL array, dimension (LDA,M)
          The m-by-m orthogonal matrix Q.

          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 is INTEGER
          The number of rows of the matrix Q to be generated.  M >= 0.

          N is INTEGER
          The number of columns of the matrix Q to be generated.
          M >= N >= 0.

          K is INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q. N >= K >= 0.

          A is REAL array, dimension (LDA,N)
          The m-by-n matrix A which was factorized by SQLT01.

          AF is REAL array, dimension (LDA,N)
          Details of the QL factorization of A, as returned by SGEQLF.
          See SGEQLF for further details.

          Q is REAL array, dimension (LDA,N)

          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 is INTEGER
          The order of the orthogonal matrix Q.  M >= 0.

          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 is INTEGER
          The number of elementary reflectors whose product defines the
          orthogonal matrix Q.  M >= K >= 0.

          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 is REAL array, dimension (LDA,N)

          CC is REAL array, dimension (LDA,N)

          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 is INTEGER
          The number of rows of the matrices A and AF.

          N is INTEGER
          The number of columns of the matrices A and AF.

          K is INTEGER
          The number of columns of AF that have been reduced
          to upper triangular form.

          A is REAL array, dimension (LDA, N)
          The original matrix A.

          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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.

          A is REAL array, dimension (LDA,N)
          The m-by-n matrix A.

          AF is REAL array, dimension (LDA,N)
          Details of the QR factorization of A, as returned by SGEQRF.
          See SGEQRF for further details.

          Q is REAL array, dimension (LDA,M)
          The m-by-m orthogonal matrix Q.

          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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.

          A is REAL array, dimension (LDA,N)
          The m-by-n matrix A.

          AF is REAL array, dimension (LDA,N)
          Details of the QR factorization of A, as returned by SGEQRFP.
          See SGEQRFP for further details.

          Q is REAL array, dimension (LDA,M)
          The m-by-m orthogonal matrix Q.

          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 is INTEGER
          The number of rows of the matrix Q to be generated.  M >= 0.

          N is INTEGER
          The number of columns of the matrix Q to be generated.
          M >= N >= 0.

          K is INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q. N >= K >= 0.

          A is REAL array, dimension (LDA,N)
          The m-by-n matrix A which was factorized by SQRT01.

          AF is REAL array, dimension (LDA,N)
          Details of the QR factorization of A, as returned by SGEQRF.
          See SGEQRF for further details.

          Q is REAL array, dimension (LDA,N)

          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 is INTEGER
          The order of the orthogonal matrix Q.  M >= 0.

          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 is INTEGER
          The number of elementary reflectors whose product defines the
          orthogonal matrix Q.  M >= K >= 0.

          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 is REAL array, dimension (LDA,N)

          CC is REAL array, dimension (LDA,N)

          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 is INTEGER
          Number of rows in test matrix.

          N is INTEGER
          Number of columns in test matrix.

          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 is INTEGER
          Number of rows in lower part of the test matrix.

          N is INTEGER
          Number of columns in test matrix.

          L is INTEGER
          The number of rows of the upper trapezoidal part the
          lower test matrix.  0 <= L <= M.

          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 is INTEGER
          The number of rows of the matrix A.

          K is INTEGER
          The number of columns of A whose subdiagonal entries
          contain information about orthogonal transformations.

          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 is INTEGER
          The number of rows of the matrix A.

          N is INTEGER
          The number of columns of the matrix 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 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 is INTEGER
          The number of rows of the matrix A.

          N is INTEGER
          The number of columns of 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 is INTEGER
          The number of rows of the matrix A.

          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 is REAL array, dimension (LDA,N)
          The M-by-N matrix A.

LDA

          LDA is INTEGER
          The leading dimension of the array A.

          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 is INTEGER
          The number of rows of the matrix A.

          N is INTEGER
          The number of columns of A.

NRHS

          NRHS is INTEGER
          The number of columns of B.

          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 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 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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          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 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 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 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 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 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 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 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 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 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 is INTEGER
          The number of rows of the matrix A.  M >= 0.

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.

          A is REAL array, dimension (LDA,N)
          The m-by-n matrix A.

          AF is REAL array, dimension (LDA,N)
          Details of the RQ factorization of A, as returned by SGERQF.
          See SGERQF for further details.

          Q is REAL array, dimension (LDA,N)
          The n-by-n orthogonal matrix Q.

          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 is INTEGER
          The number of rows of the matrix Q to be generated.  M >= 0.

          N is INTEGER
          The number of columns of the matrix Q to be generated.
          N >= M >= 0.

          K is INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q. M >= K >= 0.

          A is REAL array, dimension (LDA,N)
          The m-by-n matrix A which was factorized by SRQT01.

          AF is REAL array, dimension (LDA,N)
          Details of the RQ factorization of A, as returned by SGERQF.
          See SGERQF for further details.

          Q is REAL array, dimension (LDA,N)

          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 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 is INTEGER
          The order of the orthogonal matrix Q.  N >= 0.

          K is INTEGER
          The number of elementary reflectors whose product defines the
          orthogonal matrix Q.  N >= K >= 0.

          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 is REAL array, dimension (LDA,N)

          CC is REAL array, dimension (LDA,N)

          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 is INTEGER
          The number of rows of the matrices A and AF.

          N is INTEGER
          The number of columns of the matrices A and AF.

          A is REAL array, dimension (LDA,N)
          The original upper trapezoidal M by N matrix A.

          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 is INTEGER
          The number of rows of the matrix AF.

          N is INTEGER
          The number of columns of the matrix 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 is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.

          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 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 is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.

          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 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 is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.

          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 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 is INTEGER
          The order of the matrix A.  N >= 0.

          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 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 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 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 is INTEGER
          The order of the matrix A.  N >= 0.

          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 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 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 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 is INTEGER
          The number of rows of the matrices X, B, and XACT, and the
          order of the matrix A.  N >= 0.

          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 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 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 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 is INTEGER
          The order of the matrix A.  N >= 0.

          KD is INTEGER
          The number of superdiagonals or subdiagonals of the
          triangular band matrix A.  KD >= 0.

          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 is INTEGER
          The order of the matrix A.  N >= 0.

          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 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 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 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 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 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 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 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 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 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 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 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 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 is INTEGER
          The order of the matrix A.  N >= 0.

          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 is INTEGER
          The order of the matrix A.  N >= 0.

          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 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 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 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 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 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 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 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 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 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 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 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 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 is INTEGER
          The order of the matrix A.  N >= 0.

          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.

Functions

Detailed Description

Function Documentation

program schkaa ()

subroutine schkeq (real THRESH, integer NOUT)

subroutine schkqrt (real THRESH, logical TSTERR, integer NM, integer, dimension( * ) MVAL, integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL, integer NOUT)

subroutine schkqrtp (real THRESH, logical TSTERR, integer NM, integer, dimension( * ) MVAL, integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL, integer NOUT)

program schkrfp ()

subroutine sdrvrf1 (integer NOUT, integer NN, integer, dimension( nn ) NVAL, real THRESH, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) ARF, real, dimension( * ) WORK)

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)

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)

subroutine sebchvxx (real THRESH, character*3 PATH)

subroutine serrge (character*3 PATH, integer NUNIT)

subroutine serrgt (character*3 PATH, integer NUNIT)

subroutine serrlq (character*3 PATH, integer NUNIT)

subroutine serrls (character*3 PATH, integer NUNIT)

subroutine serrpo (character*3 PATH, integer NUNIT)

subroutine serrps (character*3 PATH, integer NUNIT)

subroutine serrql (character*3 PATH, integer NUNIT)

subroutine serrqp (character*3 PATH, integer NUNIT)

subroutine serrqr (character*3 PATH, integer NUNIT)

subroutine serrqrt (character*3 PATH, integer NUNIT)

subroutine serrqrtp (character*3 PATH, integer NUNIT)

subroutine serrrfp (integer NUNIT)

subroutine serrrq (character*3 PATH, integer NUNIT)

subroutine serrsy (character*3 PATH, integer NUNIT)

subroutine serrtr (character*3 PATH, integer NUNIT)

subroutine serrtz (character*3 PATH, integer NUNIT)

subroutine serrvx (character*3 PATH, integer NUNIT)

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)

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)

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)

logical function sgennd (integer M, integer N, real, dimension( lda, * ) A, integer LDA)

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)

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)

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)

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)

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)

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)

subroutine sget04 (integer N, integer NRHS, real, dimension( ldx, * ) X, integer LDX, real, dimension( ldxact, * ) XACT, integer LDXACT, real RCOND, real RESID)

real function sget06 (real RCOND, real RCONDC)

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)

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)

subroutine slaord (character JOB, integer N, real, dimension( * ) X, integer INCX)

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)

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)

subroutine slatb5 (character*3 PATH, integer IMAT, integer N, character TYPE, integer KL, integer KU, real ANORM, integer MODE, real CNDNUM, character DIST)

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)

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)

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)

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)

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)

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)

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)

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)

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)

subroutine spot01 (character UPLO, integer N, real, dimension( lda, * ) A, integer LDA, real, dimension( ldafac, * ) AFAC, integer LDAFAC, real, dimension( * ) RWORK, real RESID)

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)

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)

subroutine sppt01 (character UPLO, integer N, real, dimension( * ) A, real, dimension( * ) AFAC, real, dimension( * ) RWORK, real RESID)

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)

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)

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)

subroutine sptt01 (integer N, real, dimension( * ) D, real, dimension( * ) E, real, dimension( * ) DF, real, dimension( * ) EF, real, dimension( * ) WORK, real RESID)

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)

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)

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)

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)

subroutine sqrt04 (integer M, integer N, integer NB, real, dimension(6) RESULT)

subroutine sqrt05 (integer M, integer N, integer L, integer NB, real, dimension(6) RESULT)

real function sqrt11 (integer M, integer K, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) TAU, real, dimension( lwork ) WORK, integer LWORK)

real function sqrt12 (integer M, integer N, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) S, real, dimension( lwork ) WORK, integer LWORK)

subroutine sqrt13 (integer SCALE, integer M, integer N, real, dimension( lda, * ) A, integer LDA, real NORMA, integer, dimension( 4 ) ISEED)

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)

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)

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)

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)

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)

real function srzt02 (integer M, integer N, real, dimension( lda, * ) AF, integer LDA, real, dimension( * ) TAU, real, dimension( lwork ) WORK, integer LWORK)

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)

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)

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)