Functions
subroutine cbdt05 (M, N, A, LDA, S, NS, U, LDU, VT, LDVT, WORK, RESID)
subroutine dbdt01 (M, N, KD, A, LDA, Q, LDQ, D, E, PT, LDPT, WORK, RESID)
DBDT01
subroutine dbdt02 (M, N, B, LDB, C, LDC, U, LDU, WORK, RESID)
DBDT02
subroutine dbdt03 (UPLO, N, KD, D, E, U, LDU, S, VT, LDVT, WORK, RESID)
DBDT03
subroutine dbdt04 (UPLO, N, D, E, S, NS, U, LDU, VT, LDVT, WORK, RESID)
subroutine dbdt05 (M, N, A, LDA, S, NS, U, LDU, VT, LDVT, WORK, RESID)
subroutine dchkbb (NSIZES, MVAL, NVAL, NWDTHS, KK, NTYPES, DOTYPE, NRHS, ISEED, THRESH, NOUNIT, A, LDA, AB, LDAB, BD, BE, Q, LDQ, P, LDP, C, LDC, CC, WORK, LWORK, RESULT, INFO)
DCHKBB
subroutine dchkbd (NSIZES, MVAL, NVAL, NTYPES, DOTYPE, NRHS, ISEED, THRESH, A, LDA, BD, BE, S1, S2, X, LDX, Y, Z, Q, LDQ, PT, LDPT, U, VT, WORK, LWORK, IWORK, NOUT, INFO)
DCHKBD
subroutine dchkbk (NIN, NOUT)
DCHKBK
subroutine dchkbl (NIN, NOUT)
DCHKBL
subroutine dchkec (THRESH, TSTERR, NIN, NOUT)
DCHKEC
program dchkee
DCHKEE
subroutine dchkgg (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, TSTDIF, THRSHN, NOUNIT, A, LDA, B, H, T, S1, S2, P1, P2, U, LDU, V, Q, Z, ALPHR1, ALPHI1, BETA1, ALPHR3, ALPHI3, BETA3, EVECTL, EVECTR, WORK, LWORK, LLWORK, RESULT, INFO)
DCHKGG
subroutine dchkgk (NIN, NOUT)
DCHKGK
subroutine dchkgl (NIN, NOUT)
DCHKGL
subroutine dchkhs (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, H, T1, T2, U, LDU, Z, UZ, WR1, WI1, WR2, WI2, WR3, WI3, EVECTL, EVECTR, EVECTY, EVECTX, UU, TAU, WORK, NWORK, IWORK, SELECT, RESULT, INFO)
DCHKHS
subroutine dchksb (NSIZES, NN, NWDTHS, KK, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, SD, SE, U, LDU, WORK, LWORK, RESULT, INFO)
DCHKSB
subroutine dchkst (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, AP, SD, SE, D1, D2, D3, D4, D5, WA1, WA2, WA3, WR, U, LDU, V, VP, TAU, Z, WORK, LWORK, IWORK, LIWORK, RESULT, INFO)
DCHKST
subroutine dckcsd (NM, MVAL, PVAL, QVAL, NMATS, ISEED, THRESH, MMAX, X, XF, U1, U2, V1T, V2T, THETA, IWORK, WORK, RWORK, NIN, NOUT, INFO)
DCKCSD
subroutine dckglm (NN, MVAL, PVAL, NVAL, NMATS, ISEED, THRESH, NMAX, A, AF, B, BF, X, WORK, RWORK, NIN, NOUT, INFO)
DCKGLM
subroutine dckgqr (NM, MVAL, NP, PVAL, NN, NVAL, NMATS, ISEED, THRESH, NMAX, A, AF, AQ, AR, TAUA, B, BF, BZ, BT, BWK, TAUB, WORK, RWORK, NIN, NOUT, INFO)
DCKGQR
subroutine dckgsv (NM, MVAL, PVAL, NVAL, NMATS, ISEED, THRESH, NMAX, A, AF, B, BF, U, V, Q, ALPHA, BETA, R, IWORK, WORK, RWORK, NIN, NOUT, INFO)
DCKGSV
subroutine dcklse (NN, MVAL, PVAL, NVAL, NMATS, ISEED, THRESH, NMAX, A, AF, B, BF, X, WORK, RWORK, NIN, NOUT, INFO)
DCKLSE
subroutine dcsdts (M, P, Q, X, XF, LDX, U1, LDU1, U2, LDU2, V1T, LDV1T, V2T, LDV2T, THETA, IWORK, WORK, LWORK, RWORK, RESULT)
DCSDTS
subroutine ddrges (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q, LDQ, Z, ALPHAR, ALPHAI, BETA, WORK, LWORK, RESULT, BWORK, INFO)
DDRGES
subroutine ddrges3 (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q, LDQ, Z, ALPHAR, ALPHAI, BETA, WORK, LWORK, RESULT, BWORK, INFO)
DDRGES3
subroutine ddrgev (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q, LDQ, Z, QE, LDQE, ALPHAR, ALPHAI, BETA, ALPHR1, ALPHI1, BETA1, WORK, LWORK, RESULT, INFO)
DDRGEV
subroutine ddrgev3 (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q, LDQ, Z, QE, LDQE, ALPHAR, ALPHAI, BETA, ALPHR1, ALPHI1, BETA1, WORK, LWORK, RESULT, INFO)
DDRGEV3
subroutine ddrgsx (NSIZE, NCMAX, THRESH, NIN, NOUT, A, LDA, B, AI, BI, Z, Q, ALPHAR, ALPHAI, BETA, C, LDC, S, WORK, LWORK, IWORK, LIWORK, BWORK, INFO)
DDRGSX
subroutine ddrgvx (NSIZE, THRESH, NIN, NOUT, A, LDA, B, AI, BI, ALPHAR, ALPHAI, BETA, VL, VR, ILO, IHI, LSCALE, RSCALE, S, DTRU, DIF, DIFTRU, WORK, LWORK, IWORK, LIWORK, RESULT, BWORK, INFO)
DDRGVX
subroutine ddrvbd (NSIZES, MM, NN, NTYPES, DOTYPE, ISEED, THRESH, A, LDA, U, LDU, VT, LDVT, ASAV, USAV, VTSAV, S, SSAV, E, WORK, LWORK, IWORK, NOUT, INFO)
DDRVBD
subroutine ddrves (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, H, HT, WR, WI, WRT, WIT, VS, LDVS, RESULT, WORK, NWORK, IWORK, BWORK, INFO)
DDRVES
subroutine ddrvev (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, H, WR, WI, WR1, WI1, VL, LDVL, VR, LDVR, LRE, LDLRE, RESULT, WORK, NWORK, IWORK, INFO)
DDRVEV
subroutine ddrvsg (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, LDB, D, Z, LDZ, AB, BB, AP, BP, WORK, NWORK, IWORK, LIWORK, RESULT, INFO)
DDRVSG
subroutine ddrvst (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, D1, D2, D3, D4, EVEIGS, WA1, WA2, WA3, U, LDU, V, TAU, Z, WORK, LWORK, IWORK, LIWORK, RESULT, INFO)
DDRVST
subroutine ddrvsx (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NIUNIT, NOUNIT, A, LDA, H, HT, WR, WI, WRT, WIT, WRTMP, WITMP, VS, LDVS, VS1, RESULT, WORK, LWORK, IWORK, BWORK, INFO)
DDRVSX
subroutine ddrvvx (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NIUNIT, NOUNIT, A, LDA, H, WR, WI, WR1, WI1, VL, LDVL, VR, LDVR, LRE, LDLRE, RCONDV, RCNDV1, RCDVIN, RCONDE, RCNDE1, RCDEIN, SCALE, SCALE1, RESULT, WORK, NWORK, IWORK, INFO)
DDRVVX
subroutine derrbd (PATH, NUNIT)
DERRBD
subroutine derrec (PATH, NUNIT)
DERREC
subroutine derred (PATH, NUNIT)
DERRED
subroutine derrgg (PATH, NUNIT)
DERRGG
subroutine derrhs (PATH, NUNIT)
DERRHS
subroutine derrst (PATH, NUNIT)
DERRST
subroutine dget02 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
DGET02
subroutine dget10 (M, N, A, LDA, B, LDB, WORK, RESULT)
DGET10
subroutine dget22 (TRANSA, TRANSE, TRANSW, N, A, LDA, E, LDE, WR, WI, WORK, RESULT)
DGET22
subroutine dget23 (COMP, BALANC, JTYPE, THRESH, ISEED, NOUNIT, N, A, LDA, H, WR, WI, WR1, WI1, VL, LDVL, VR, LDVR, LRE, LDLRE, RCONDV, RCNDV1, RCDVIN, RCONDE, RCNDE1, RCDEIN, SCALE, SCALE1, RESULT, WORK, LWORK, IWORK, INFO)
DGET23
subroutine dget24 (COMP, JTYPE, THRESH, ISEED, NOUNIT, N, A, LDA, H, HT, WR, WI, WRT, WIT, WRTMP, WITMP, VS, LDVS, VS1, RCDEIN, RCDVIN, NSLCT, ISLCT, RESULT, WORK, LWORK, IWORK, BWORK, INFO)
DGET24
subroutine dget31 (RMAX, LMAX, NINFO, KNT)
DGET31
subroutine dget32 (RMAX, LMAX, NINFO, KNT)
DGET32
subroutine dget33 (RMAX, LMAX, NINFO, KNT)
DGET33
subroutine dget34 (RMAX, LMAX, NINFO, KNT)
DGET34
subroutine dget35 (RMAX, LMAX, NINFO, KNT)
DGET35
subroutine dget36 (RMAX, LMAX, NINFO, KNT, NIN)
DGET36
subroutine dget37 (RMAX, LMAX, NINFO, KNT, NIN)
DGET37
subroutine dget38 (RMAX, LMAX, NINFO, KNT, NIN)
DGET38
subroutine dget39 (RMAX, LMAX, NINFO, KNT)
DGET39
subroutine dget51 (ITYPE, N, A, LDA, B, LDB, U, LDU, V, LDV, WORK, RESULT)
DGET51
subroutine dget52 (LEFT, N, A, LDA, B, LDB, E, LDE, ALPHAR, ALPHAI, BETA, WORK, RESULT)
DGET52
subroutine dget53 (A, LDA, B, LDB, SCALE, WR, WI, RESULT, INFO)
DGET53
subroutine dget54 (N, A, LDA, B, LDB, S, LDS, T, LDT, U, LDU, V, LDV, WORK, RESULT)
DGET54
subroutine dglmts (N, M, P, A, AF, LDA, B, BF, LDB, D, DF, X, U, WORK, LWORK, RWORK, RESULT)
DGLMTS
subroutine dgqrts (N, M, P, A, AF, Q, R, LDA, TAUA, B, BF, Z, T, BWK, LDB, TAUB, WORK, LWORK, RWORK, RESULT)
DGQRTS
subroutine dgrqts (M, P, N, A, AF, Q, R, LDA, TAUA, B, BF, Z, T, BWK, LDB, TAUB, WORK, LWORK, RWORK, RESULT)
DGRQTS
subroutine dgsvts3 (M, P, N, A, AF, LDA, B, BF, LDB, U, LDU, V, LDV, Q, LDQ, ALPHA, BETA, R, LDR, IWORK, WORK, LWORK, RWORK, RESULT)
DGSVTS3
subroutine dhst01 (N, ILO, IHI, A, LDA, H, LDH, Q, LDQ, WORK, LWORK, RESULT)
DHST01
subroutine dlafts (TYPE, M, N, IMAT, NTESTS, RESULT, ISEED, THRESH, IOUNIT, IE)
DLAFTS
subroutine dlahd2 (IOUNIT, PATH)
DLAHD2
subroutine dlarfy (UPLO, N, V, INCV, TAU, C, LDC, WORK)
DLARFY
subroutine dlarhs (PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO)
DLARHS
subroutine dlasum (TYPE, IOUNIT, IE, NRUN)
DLASUM
subroutine dlatb9 (PATH, IMAT, M, P, N, TYPE, KLA, KUA, KLB, KUB, ANORM, BNORM, MODEA, MODEB, CNDNMA, CNDNMB, DISTA, DISTB)
DLATB9
subroutine dlatm4 (ITYPE, N, NZ1, NZ2, ISIGN, AMAGN, RCOND, TRIANG, IDIST, ISEED, A, LDA)
DLATM4
logical function dlctes (ZR, ZI, D)
DLCTES
logical function dlctsx (AR, AI, BETA)
DLCTSX
subroutine dlsets (M, P, N, A, AF, LDA, B, BF, LDB, C, CF, D, DF, X, WORK, LWORK, RWORK, RESULT)
DLSETS
subroutine dort01 (ROWCOL, M, N, U, LDU, WORK, LWORK, RESID)
DORT01
subroutine dort03 (RC, MU, MV, N, K, U, LDU, V, LDV, WORK, LWORK, RESULT, INFO)
DORT03
subroutine dsbt21 (UPLO, N, KA, KS, A, LDA, D, E, U, LDU, WORK, RESULT)
DSBT21
subroutine dsgt01 (ITYPE, UPLO, N, M, A, LDA, B, LDB, Z, LDZ, D, WORK, RESULT)
DSGT01
logical function dslect (ZR, ZI)
DSLECT
subroutine dspt21 (ITYPE, UPLO, N, KBAND, AP, D, E, U, LDU, VP, TAU, WORK, RESULT)
DSPT21
subroutine dstech (N, A, B, EIG, TOL, WORK, INFO)
DSTECH
subroutine dstect (N, A, B, SHIFT, NUM)
DSTECT
subroutine dstt21 (N, KBAND, AD, AE, SD, SE, U, LDU, WORK, RESULT)
DSTT21
subroutine dstt22 (N, M, KBAND, AD, AE, SD, SE, U, LDU, WORK, LDWORK, RESULT)
DSTT22
subroutine dsvdch (N, S, E, SVD, TOL, INFO)
DSVDCH
subroutine dsvdct (N, S, E, SHIFT, NUM)
DSVDCT
double precision function dsxt1 (IJOB, D1, N1, D2, N2, ABSTOL, ULP, UNFL)
DSXT1
subroutine dsyt21 (ITYPE, UPLO, N, KBAND, A, LDA, D, E, U, LDU, V, LDV, TAU, WORK, RESULT)
DSYT21
subroutine dsyt22 (ITYPE, UPLO, N, M, KBAND, A, LDA, D, E, U, LDU, V, LDV, TAU, WORK, RESULT)
DSYT22
subroutine sbdt04 (UPLO, N, D, E, S, NS, U, LDU, VT, LDVT, WORK, RESID)
subroutine sbdt05 (M, N, A, LDA, S, NS, U, LDU, VT, LDVT, WORK, RESID)
subroutine zbdt05 (M, N, A, LDA, S, NS, U, LDU, VT, LDVT, WORK, RESID)
Detailed Description
This is the group of double LAPACK TESTING EIG routines.
Function Documentation
subroutine cbdt05 (integer M, integer N, complex, dimension( lda, * ) A, integer LDA, real, dimension( * ) S, integer NS, complex, dimension( * ) U, integer LDU, complex, dimension( ldvt, * ) VT, integer LDVT, complex, dimension( * ) WORK, real RESID)
Purpose:
CBDT05 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.
The test ratio to test the singular value decomposition is RESID = norm( S  U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.
Parameters:

M
M is INTEGER The number of rows of the matrices A and U.
NN is INTEGER The number of columns of the matrices A and VT.
AA is COMPLEX array, dimension (LDA,N) The m by n matrix A.
aram[in] LDA leading dimension of the array A. LDA >= max(1,M).
SS is REAL array, dimension (NS) The singular values from the (partial) SVD of B, sorted in decreasing order.
NSNS is INTEGER The number of singular values/vectors from the (partial) SVD of B.
UU is COMPLEX array, dimension (LDU,NS) The n by ns orthogonal matrix U in S = U' * B * V.
LDULDU is INTEGER The leading dimension of the array U. LDU >= max(1,N)
VTVT is COMPLEX array, dimension (LDVT,N) The n by ns orthogonal matrix V in S = U' * B * V.
LDVTLDVT is INTEGER The leading dimension of the array VT.
WORKWORK is COMPLEX array, dimension (M,N)
RESIDRESID is REAL The test ratio: norm(S  U' * A * V) / ( n * norm(A) * EPS )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dbdt01 (integer M, integer N, integer KD, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldpt, * ) PT, integer LDPT, double precision, dimension( * ) WORK, double precision RESID)
DBDT01
Purpose:

DBDT01 reconstructs a general matrix A from its bidiagonal form A = Q * B * P' where Q (m by min(m,n)) and P' (min(m,n) by n) are orthogonal matrices and B is bidiagonal. The test ratio to test the reduction is RESID = norm( A  Q * B * PT ) / ( n * norm(A) * EPS ) where PT = P' and EPS is the machine precision.
Parameters:

M
M is INTEGER The number of rows of the matrices A and Q.
NN is INTEGER The number of columns of the matrices A and P'.
KDKD is INTEGER If KD = 0, B is diagonal and the array E is not referenced. If KD = 1, the reduction was performed by xGEBRD; B is upper bidiagonal if M >= N, and lower bidiagonal if M < N. If KD = 1, the reduction was performed by xGBBRD; B is always upper bidiagonal.
AA is DOUBLE PRECISION array, dimension (LDA,N) The m by n matrix A.
LDALDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).
QQ is DOUBLE PRECISION array, dimension (LDQ,N) The m by min(m,n) orthogonal matrix Q in the reduction A = Q * B * P'.
LDQLDQ is INTEGER The leading dimension of the array Q. LDQ >= max(1,M).
DD is DOUBLE PRECISION array, dimension (min(M,N)) The diagonal elements of the bidiagonal matrix B.
EE is DOUBLE PRECISION array, dimension (min(M,N)1) The superdiagonal elements of the bidiagonal matrix B if m >= n, or the subdiagonal elements of B if m < n.
PTPT is DOUBLE PRECISION array, dimension (LDPT,N) The min(m,n) by n orthogonal matrix P' in the reduction A = Q * B * P'.
LDPTLDPT is INTEGER The leading dimension of the array PT. LDPT >= max(1,min(M,N)).
WORKWORK is DOUBLE PRECISION array, dimension (M+N)
RESIDRESID is DOUBLE PRECISION The test ratio: norm(A  Q * B * P') / ( n * norm(A) * EPS )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dbdt02 (integer M, integer N, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( ldc, * ) C, integer LDC, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) WORK, double precision RESID)
DBDT02
Purpose:

DBDT02 tests the change of basis C = U' * B by computing the residual RESID = norm( B  U * C ) / ( max(m,n) * norm(B) * EPS ), where B and C are M by N matrices, U is an M by M orthogonal matrix, and EPS is the machine precision.
Parameters:

M
M is INTEGER The number of rows of the matrices B and C and the order of the matrix Q.
NN is INTEGER The number of columns of the matrices B and C.
BB is DOUBLE PRECISION array, dimension (LDB,N) The m by n matrix B.
LDBLDB is INTEGER The leading dimension of the array B. LDB >= max(1,M).
CC is DOUBLE PRECISION array, dimension (LDC,N) The m by n matrix C, assumed to contain U' * B.
LDCLDC is INTEGER The leading dimension of the array C. LDC >= max(1,M).
UU is DOUBLE PRECISION array, dimension (LDU,M) The m by m orthogonal matrix U.
LDULDU is INTEGER The leading dimension of the array U. LDU >= max(1,M).
WORKWORK is DOUBLE PRECISION array, dimension (M)
RESIDRESID is DOUBLE PRECISION RESID = norm( B  U * C ) / ( max(m,n) * norm(B) * EPS ),
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dbdt03 (character UPLO, integer N, integer KD, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) S, double precision, dimension( ldvt, * ) VT, integer LDVT, double precision, dimension( * ) WORK, double precision RESID)
DBDT03
Purpose:

DBDT03 reconstructs a bidiagonal matrix B from its SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal. The test ratio to test the singular value decomposition is RESID = norm( B  U * S * VT ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.
Parameters:

UPLO
UPLO is CHARACTER*1 Specifies whether the matrix B is upper or lower bidiagonal. = 'U': Upper bidiagonal = 'L': Lower bidiagonal
NN is INTEGER The order of the matrix B.
KDKD is INTEGER The bandwidth of the bidiagonal matrix B. If KD = 1, the matrix B is bidiagonal, and if KD = 0, B is diagonal and E is not referenced. If KD is greater than 1, it is assumed to be 1, and if KD is less than 0, it is assumed to be 0.
DD is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the bidiagonal matrix B.
EE is DOUBLE PRECISION array, dimension (N1) The (n1) superdiagonal elements of the bidiagonal matrix B if UPLO = 'U', or the (n1) subdiagonal elements of B if UPLO = 'L'.
UU is DOUBLE PRECISION array, dimension (LDU,N) The n by n orthogonal matrix U in the reduction B = U'*A*P.
LDULDU is INTEGER The leading dimension of the array U. LDU >= max(1,N)
SS is DOUBLE PRECISION array, dimension (N) The singular values from the SVD of B, sorted in decreasing order.
VTVT is DOUBLE PRECISION array, dimension (LDVT,N) The n by n orthogonal matrix V' in the reduction B = U * S * V'.
LDVTLDVT is INTEGER The leading dimension of the array VT.
WORKWORK is DOUBLE PRECISION array, dimension (2*N)
RESIDRESID is DOUBLE PRECISION The test ratio: norm(B  U * S * V') / ( n * norm(A) * EPS )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dbdt04 (character UPLO, integer N, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( * ) S, integer NS, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldvt, * ) VT, integer LDVT, double precision, dimension( * ) WORK, double precision RESID)
Purpose:
DBDT04 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.
The test ratio to test the singular value decomposition is RESID = norm( S  U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.
Parameters:

UPLO
UPLO is CHARACTER*1 Specifies whether the matrix B is upper or lower bidiagonal. = 'U': Upper bidiagonal = 'L': Lower bidiagonal
NN is INTEGER The order of the matrix B.
DD is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the bidiagonal matrix B.
EE is DOUBLE PRECISION array, dimension (N1) The (n1) superdiagonal elements of the bidiagonal matrix B if UPLO = 'U', or the (n1) subdiagonal elements of B if UPLO = 'L'.
SS is DOUBLE PRECISION array, dimension (NS) The singular values from the (partial) SVD of B, sorted in decreasing order.
NSNS is INTEGER The number of singular values/vectors from the (partial) SVD of B.
UU is DOUBLE PRECISION array, dimension (LDU,NS) The n by ns orthogonal matrix U in S = U' * B * V.
LDULDU is INTEGER The leading dimension of the array U. LDU >= max(1,N)
VTVT is DOUBLE PRECISION array, dimension (LDVT,N) The n by ns orthogonal matrix V in S = U' * B * V.
LDVTLDVT is INTEGER The leading dimension of the array VT.
WORKWORK is DOUBLE PRECISION array, dimension (2*N)
RESIDRESID is DOUBLE PRECISION The test ratio: norm(S  U' * B * V) / ( n * norm(B) * EPS )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dbdt05 (integer M, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) S, integer NS, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldvt, * ) VT, integer LDVT, double precision, dimension( * ) WORK, double precision RESID)
Purpose:
DBDT05 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.
The test ratio to test the singular value decomposition is RESID = norm( S  U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.
Parameters:

M
M is INTEGER The number of rows of the matrices A and U.
NN is INTEGER The number of columns of the matrices A and VT.
AA is DOUBLE PRECISION array, dimension (LDA,N) The m by n matrix A.
aram[in] LDA leading dimension of the array A. LDA >= max(1,M).
SS is DOUBLE PRECISION array, dimension (NS) The singular values from the (partial) SVD of B, sorted in decreasing order.
NSNS is INTEGER The number of singular values/vectors from the (partial) SVD of B.
UU is DOUBLE PRECISION array, dimension (LDU,NS) The n by ns orthogonal matrix U in S = U' * B * V.
LDULDU is INTEGER The leading dimension of the array U. LDU >= max(1,N)
VTVT is DOUBLE PRECISION array, dimension (LDVT,N) The n by ns orthogonal matrix V in S = U' * B * V.
LDVTLDVT is INTEGER The leading dimension of the array VT.
WORKWORK is DOUBLE PRECISION array, dimension (M,N)
RESIDRESID is DOUBLE PRECISION The test ratio: norm(S  U' * A * V) / ( n * norm(A) * EPS )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dchkbb (integer NSIZES, integer, dimension( * ) MVAL, integer, dimension( * ) NVAL, integer NWDTHS, integer, dimension( * ) KK, integer NTYPES, logical, dimension( * ) DOTYPE, integer NRHS, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldab, * ) AB, integer LDAB, double precision, dimension( * ) BD, double precision, dimension( * ) BE, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldp, * ) P, integer LDP, double precision, dimension( ldc, * ) C, integer LDC, double precision, dimension( ldc, * ) CC, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RESULT, integer INFO)
DCHKBB
Purpose:

DCHKBB tests the reduction of a general real rectangular band matrix to bidiagonal form. DGBBRD factors a general band matrix A as Q B P* , where * means transpose, B is upper bidiagonal, and Q and P are orthogonal; DGBBRD can also overwrite a given matrix C with Q* C . For each pair of matrix dimensions (M,N) and each selected matrix type, an M by N matrix A and an M by NRHS matrix C are generated. The problem dimensions are as follows A: M x N Q: M x M P: N x N B: min(M,N) x min(M,N) C: M x NRHS For each generated matrix, 4 tests are performed: (1)  A  Q B PT  / ( A max(M,N) ulp ), PT = P' (2)  I  Q' Q  / ( M ulp ) (3)  I  PT PT'  / ( N ulp ) (4)  Y  Q' C  / ( Y max(M,NRHS) ulp ), where Y = Q' C. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: The possible matrix types are (1) The zero matrix. (2) The identity matrix. (3) A diagonal matrix with evenly spaced entries 1, ..., ULP and random signs. (ULP = (first number larger than 1)  1 ) (4) A diagonal matrix with geometrically spaced entries 1, ..., ULP and random signs. (5) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP and random signs. (6) Same as (3), but multiplied by SQRT( overflow threshold ) (7) Same as (3), but multiplied by SQRT( underflow threshold ) (8) A matrix of the form U D V, where U and V are orthogonal and D has evenly spaced entries 1, ..., ULP with random signs on the diagonal. (9) A matrix of the form U D V, where U and V are orthogonal and D has geometrically spaced entries 1, ..., ULP with random signs on the diagonal. (10) A matrix of the form U D V, where U and V are orthogonal and D has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal. (11) Same as (8), but multiplied by SQRT( overflow threshold ) (12) Same as (8), but multiplied by SQRT( underflow threshold ) (13) Rectangular matrix with random entries chosen from (1,1). (14) Same as (13), but multiplied by SQRT( overflow threshold ) (15) Same as (13), but multiplied by SQRT( underflow threshold )
Parameters:

NSIZES
NSIZES is INTEGER The number of values of M and N contained in the vectors MVAL and NVAL. The matrix sizes are used in pairs (M,N). If NSIZES is zero, DCHKBB does nothing. NSIZES must be at least zero.
MVALMVAL is INTEGER array, dimension (NSIZES) The values of the matrix row dimension M.
NVALNVAL is INTEGER array, dimension (NSIZES) The values of the matrix column dimension N.
NWDTHSNWDTHS is INTEGER The number of bandwidths to use. If it is zero, DCHKBB does nothing. It must be at least zero.
KKKK is INTEGER array, dimension (NWDTHS) An array containing the bandwidths to be used for the band matrices. The values must be at least zero.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DCHKBB does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
NRHSNRHS is INTEGER The number of columns in the "righthand side" matrix C. If NRHS = 0, then the operations on the righthand side will not be tested. NRHS must be at least 0.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DCHKBB to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.)
AA is DOUBLE PRECISION array, dimension (LDA, max(NN)) Used to hold the matrix A.
LDALDA is INTEGER The leading dimension of A. It must be at least 1 and at least max( NN ).
ABAB is DOUBLE PRECISION array, dimension (LDAB, max(NN)) Used to hold A in band storage format.
LDABLDAB is INTEGER The leading dimension of AB. It must be at least 2 (not 1!) and at least max( KK )+1.
BDBD is DOUBLE PRECISION array, dimension (max(NN)) Used to hold the diagonal of the bidiagonal matrix computed by DGBBRD.
BEBE is DOUBLE PRECISION array, dimension (max(NN)) Used to hold the offdiagonal of the bidiagonal matrix computed by DGBBRD.
QQ is DOUBLE PRECISION array, dimension (LDQ, max(NN)) Used to hold the orthogonal matrix Q computed by DGBBRD.
LDQLDQ is INTEGER The leading dimension of Q. It must be at least 1 and at least max( NN ).
PP is DOUBLE PRECISION array, dimension (LDP, max(NN)) Used to hold the orthogonal matrix P computed by DGBBRD.
LDPLDP is INTEGER The leading dimension of P. It must be at least 1 and at least max( NN ).
CC is DOUBLE PRECISION array, dimension (LDC, max(NN)) Used to hold the matrix C updated by DGBBRD.
LDCLDC is INTEGER The leading dimension of U. It must be at least 1 and at least max( NN ).
CCCC is DOUBLE PRECISION array, dimension (LDC, max(NN)) Used to hold a copy of the matrix C.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The number of entries in WORK. This must be at least max( LDA+1, max(NN)+1 )*max(NN).
RESULTRESULT is DOUBLE PRECISION array, dimension (4) The values computed by the tests described above. The values are currently limited to 1/ulp, to avoid overflow.
INFOINFO is INTEGER If 0, then everything ran OK.  Some Local Variables and Parameters:      ZERO, ONE Real 0 and 1. MAXTYP The number of types defined. NTEST The number of tests performed, or which can be performed so far, for the current matrix. NTESTT The total number of tests performed so far. NMAX Largest value in NN. NMATS The number of matrices generated so far. NERRS The number of tests which have exceeded THRESH so far. COND, IMODE Values to be passed to the matrix generators. ANORM Norm of A; passed to matrix generators. OVFL, UNFL Overflow and underflow thresholds. ULP, ULPINV Finest relative precision and its inverse. RTOVFL, RTUNFL Square roots of the previous 2 values. The following four arrays decode JTYPE: KTYPE(j) The general type (110) for type "j". KMODE(j) The MODE value to be passed to the matrix generator for type "j". KMAGN(j) The order of magnitude ( O(1), O(overflow^(1/2) ), O(underflow^(1/2) )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dchkbd (integer NSIZES, integer, dimension( * ) MVAL, integer, dimension( * ) NVAL, integer NTYPES, logical, dimension( * ) DOTYPE, integer NRHS, integer, dimension( 4 ) ISEED, double precision THRESH, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) BD, double precision, dimension( * ) BE, double precision, dimension( * ) S1, double precision, dimension( * ) S2, double precision, dimension( ldx, * ) X, integer LDX, double precision, dimension( ldx, * ) Y, double precision, dimension( ldx, * ) Z, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldpt, * ) PT, integer LDPT, double precision, dimension( ldpt, * ) U, double precision, dimension( ldpt, * ) VT, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer NOUT, integer INFO)
DCHKBD
Purpose:

DCHKBD checks the singular value decomposition (SVD) routines. DGEBRD reduces a real general m by n matrix A to upper or lower bidiagonal form B by an orthogonal transformation: Q' * A * P = B (or A = Q * B * P'). The matrix B is upper bidiagonal if m >= n and lower bidiagonal if m < n. DORGBR generates the orthogonal matrices Q and P' from DGEBRD. Note that Q and P are not necessarily square. DBDSQR computes the singular value decomposition of the bidiagonal matrix B as B = U S V'. It is called three times to compute 1) B = U S1 V', where S1 is the diagonal matrix of singular values and the columns of the matrices U and V are the left and right singular vectors, respectively, of B. 2) Same as 1), but the singular values are stored in S2 and the singular vectors are not computed. 3) A = (UQ) S (P'V'), the SVD of the original matrix A. In addition, DBDSQR has an option to apply the left orthogonal matrix U to a matrix X, useful in least squares applications. DBDSDC computes the singular value decomposition of the bidiagonal matrix B as B = U S V' using divideandconquer. It is called twice to compute 1) B = U S1 V', where S1 is the diagonal matrix of singular values and the columns of the matrices U and V are the left and right singular vectors, respectively, of B. 2) Same as 1), but the singular values are stored in S2 and the singular vectors are not computed. DBDSVDX computes the singular value decomposition of the bidiagonal matrix B as B = U S V' using bisection and inverse iteration. It is called six times to compute 1) B = U S1 V', RANGE='A', where S1 is the diagonal matrix of singular values and the columns of the matrices U and V are the left and right singular vectors, respectively, of B. 2) Same as 1), but the singular values are stored in S2 and the singular vectors are not computed. 3) B = U S1 V', RANGE='I', with where S1 is the diagonal matrix of singular values and the columns of the matrices U and V are the left and right singular vectors, respectively, of B 4) Same as 3), but the singular values are stored in S2 and the singular vectors are not computed. 5) B = U S1 V', RANGE='V', with where S1 is the diagonal matrix of singular values and the columns of the matrices U and V are the left and right singular vectors, respectively, of B 6) Same as 5), but the singular values are stored in S2 and the singular vectors are not computed. For each pair of matrix dimensions (M,N) and each selected matrix type, an M by N matrix A and an M by NRHS matrix X are generated. The problem dimensions are as follows A: M x N Q: M x min(M,N) (but M x M if NRHS > 0) P: min(M,N) x N B: min(M,N) x min(M,N) U, V: min(M,N) x min(M,N) S1, S2 diagonal, order min(M,N) X: M x NRHS For each generated matrix, 14 tests are performed: Test DGEBRD and DORGBR (1)  A  Q B PT  / ( A max(M,N) ulp ), PT = P' (2)  I  Q' Q  / ( M ulp ) (3)  I  PT PT'  / ( N ulp ) Test DBDSQR on bidiagonal matrix B (4)  B  U S1 VT  / ( B min(M,N) ulp ), VT = V' (5)  Y  U Z  / ( Y max(min(M,N),k) ulp ), where Y = Q' X and Z = U' Y. (6)  I  U' U  / ( min(M,N) ulp ) (7)  I  VT VT'  / ( min(M,N) ulp ) (8) S1 contains min(M,N) nonnegative values in decreasing order. (Return 0 if true, 1/ULP if false.) (9)  S1  S2  / ( S1 ulp ), where S2 is computed without computing U and V. (10) 0 if the true singular values of B are within THRESH of those in S1. 2*THRESH if they are not. (Tested using DSVDCH) Test DBDSQR on matrix A (11)  A  (QU) S (VT PT)  / ( A max(M,N) ulp ) (12)  X  (QU) Z  / ( X max(M,k) ulp ) (13)  I  (QU)'(QU)  / ( M ulp ) (14)  I  (VT PT) (PT'VT')  / ( N ulp ) Test DBDSDC on bidiagonal matrix B (15)  B  U S1 VT  / ( B min(M,N) ulp ), VT = V' (16)  I  U' U  / ( min(M,N) ulp ) (17)  I  VT VT'  / ( min(M,N) ulp ) (18) S1 contains min(M,N) nonnegative values in decreasing order. (Return 0 if true, 1/ULP if false.) (19)  S1  S2  / ( S1 ulp ), where S2 is computed without computing U and V. Test DBDSVDX on bidiagonal matrix B (20)  B  U S1 VT  / ( B min(M,N) ulp ), VT = V' (21)  I  U' U  / ( min(M,N) ulp ) (22)  I  VT VT'  / ( min(M,N) ulp ) (23) S1 contains min(M,N) nonnegative values in decreasing order. (Return 0 if true, 1/ULP if false.) (24)  S1  S2  / ( S1 ulp ), where S2 is computed without computing U and V. (25)  S1  U' B VT'  / ( S n ulp ) DBDSVDX('V', 'I') (26)  I  U' U  / ( min(M,N) ulp ) (27)  I  VT VT'  / ( min(M,N) ulp ) (28) S1 contains min(M,N) nonnegative values in decreasing order. (Return 0 if true, 1/ULP if false.) (29)  S1  S2  / ( S1 ulp ), where S2 is computed without computing U and V. (30)  S1  U' B VT'  / ( S1 n ulp ) DBDSVDX('V', 'V') (31)  I  U' U  / ( min(M,N) ulp ) (32)  I  VT VT'  / ( min(M,N) ulp ) (33) S1 contains min(M,N) nonnegative values in decreasing order. (Return 0 if true, 1/ULP if false.) (34)  S1  S2  / ( S1 ulp ), where S2 is computed without computing U and V. The possible matrix types are (1) The zero matrix. (2) The identity matrix. (3) A diagonal matrix with evenly spaced entries 1, ..., ULP and random signs. (ULP = (first number larger than 1)  1 ) (4) A diagonal matrix with geometrically spaced entries 1, ..., ULP and random signs. (5) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP and random signs. (6) Same as (3), but multiplied by SQRT( overflow threshold ) (7) Same as (3), but multiplied by SQRT( underflow threshold ) (8) A matrix of the form U D V, where U and V are orthogonal and D has evenly spaced entries 1, ..., ULP with random signs on the diagonal. (9) A matrix of the form U D V, where U and V are orthogonal and D has geometrically spaced entries 1, ..., ULP with random signs on the diagonal. (10) A matrix of the form U D V, where U and V are orthogonal and D has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal. (11) Same as (8), but multiplied by SQRT( overflow threshold ) (12) Same as (8), but multiplied by SQRT( underflow threshold ) (13) Rectangular matrix with random entries chosen from (1,1). (14) Same as (13), but multiplied by SQRT( overflow threshold ) (15) Same as (13), but multiplied by SQRT( underflow threshold ) Special case: (16) A bidiagonal matrix with random entries chosen from a logarithmic distribution on [ulp^2,ulp^(2)] (I.e., each entry is e^x, where x is chosen uniformly on [ 2 log(ulp), 2 log(ulp) ] .) For *this* type: (a) DGEBRD is not called to reduce it to bidiagonal form. (b) the bidiagonal is min(M,N) x min(M,N); if M<N, the matrix will be lower bidiagonal, otherwise upper. (c) only tests 58 and 14 are performed. A subset of the full set of matrix types may be selected through the logical array DOTYPE.
Parameters:

NSIZES
NSIZES is INTEGER The number of values of M and N contained in the vectors MVAL and NVAL. The matrix sizes are used in pairs (M,N).
MVALMVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
NVALNVAL is INTEGER array, dimension (NM) The values of the matrix column dimension N.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DCHKBD does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrices are in A and B. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size (m,n), a matrix of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
NRHSNRHS is INTEGER The number of columns in the "righthand side" matrices X, Y, and Z, used in testing DBDSQR. If NRHS = 0, then the operations on the righthand side will not be tested. NRHS must be at least 0.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The values of ISEED are changed on exit, and can be used in the next call to DCHKBD to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. Note that the expected value of the test ratios is O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100.
AA is DOUBLE PRECISION array, dimension (LDA,NMAX) where NMAX is the maximum value of N in NVAL.
LDALDA is INTEGER The leading dimension of the array A. LDA >= max(1,MMAX), where MMAX is the maximum value of M in MVAL.
BDBD is DOUBLE PRECISION array, dimension (max(min(MVAL(j),NVAL(j))))
BEBE is DOUBLE PRECISION array, dimension (max(min(MVAL(j),NVAL(j))))
S1S1 is DOUBLE PRECISION array, dimension (max(min(MVAL(j),NVAL(j))))
S2S2 is DOUBLE PRECISION array, dimension (max(min(MVAL(j),NVAL(j))))
XX is DOUBLE PRECISION array, dimension (LDX,NRHS)
LDXLDX is INTEGER The leading dimension of the arrays X, Y, and Z. LDX >= max(1,MMAX)
YY is DOUBLE PRECISION array, dimension (LDX,NRHS)
ZZ is DOUBLE PRECISION array, dimension (LDX,NRHS)
QQ is DOUBLE PRECISION array, dimension (LDQ,MMAX)
LDQLDQ is INTEGER The leading dimension of the array Q. LDQ >= max(1,MMAX).
PTPT is DOUBLE PRECISION array, dimension (LDPT,NMAX)
LDPTLDPT is INTEGER The leading dimension of the arrays PT, U, and V. LDPT >= max(1, max(min(MVAL(j),NVAL(j)))).
UU is DOUBLE PRECISION array, dimension (LDPT,max(min(MVAL(j),NVAL(j))))
VTVT is DOUBLE PRECISION array, dimension (LDPT,max(min(MVAL(j),NVAL(j))))
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The number of entries in WORK. This must be at least 3(M+N) and M(M + max(M,N,k) + 1) + N*min(M,N) for all pairs (M,N)=(MM(j),NN(j))
IWORKIWORK is INTEGER array, dimension at least 8*min(M,N)
NOUTNOUT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.)
INFOINFO is INTEGER If 0, then everything ran OK. 1: NSIZES < 0 2: Some MM(j) < 0 3: Some NN(j) < 0 4: NTYPES < 0 6: NRHS < 0 8: THRESH < 0 11: LDA < 1 or LDA < MMAX, where MMAX is max( MM(j) ). 17: LDB < 1 or LDB < MMAX. 21: LDQ < 1 or LDQ < MMAX. 23: LDPT< 1 or LDPT< MNMAX. 27: LWORK too small. If DLATMR, SLATMS, DGEBRD, DORGBR, or DBDSQR, returns an error code, the absolute value of it is returned.  Some Local Variables and Parameters:      ZERO, ONE Real 0 and 1. MAXTYP The number of types defined. NTEST The number of tests performed, or which can be performed so far, for the current matrix. MMAX Largest value in NN. NMAX Largest value in NN. MNMIN min(MM(j), NN(j)) (the dimension of the bidiagonal matrix.) MNMAX The maximum value of MNMIN for j=1,...,NSIZES. NFAIL The number of tests which have exceeded THRESH COND, IMODE Values to be passed to the matrix generators. ANORM Norm of A; passed to matrix generators. OVFL, UNFL Overflow and underflow thresholds. RTOVFL, RTUNFL Square roots of the previous 2 values. ULP, ULPINV Finest relative precision and its inverse. The following four arrays decode JTYPE: KTYPE(j) The general type (110) for type "j". KMODE(j) The MODE value to be passed to the matrix generator for type "j". KMAGN(j) The order of magnitude ( O(1), O(overflow^(1/2) ), O(underflow^(1/2) )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine dchkbk (integer NIN, integer NOUT)
DCHKBK
Purpose:

DCHKBK tests DGEBAK, a routine for backward transformation of the computed right or left eigenvectors if the original matrix was preprocessed by balance subroutine DGEBAL.
Parameters:

NIN
NIN is INTEGER The logical unit number for input. NIN > 0.
NOUTNOUT is INTEGER The logical unit number for output. NOUT > 0.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dchkbl (integer NIN, integer NOUT)
DCHKBL
Purpose:

DCHKBL tests DGEBAL, a routine for balancing a general real matrix and isolating some of its eigenvalues.
Parameters:

NIN
NIN is INTEGER The logical unit number for input. NIN > 0.
NOUTNOUT is INTEGER The logical unit number for output. NOUT > 0.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dchkec (double precision THRESH, logical TSTERR, integer NIN, integer NOUT)
DCHKEC
Purpose:

DCHKEC tests eigen condition estimation routines DLALN2, DLASY2, DLANV2, DLAQTR, DLAEXC, DTRSYL, DTREXC, DTRSNA, DTRSEN In all cases, the routine runs through a fixed set of numerical examples, subjects them to various tests, and compares the test results to a threshold THRESH. In addition, DTREXC, DTRSNA and DTRSEN are tested by reading in precomputed examples from a file (on input unit NIN). Output is written to output unit NOUT.
Parameters:

THRESH
THRESH is DOUBLE PRECISION Threshold for residual tests. A computed test ratio passes the threshold if it is less than THRESH.
TSTERRTSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
NINNIN is INTEGER The logical unit number for input.
NOUTNOUT is INTEGER The logical unit number for output.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
program dchkee ()
DCHKEE
Purpose:

DCHKEE tests the DOUBLE PRECISION LAPACK subroutines for the matrix eigenvalue problem. The test paths in this version are NEP (Nonsymmetric Eigenvalue Problem): Test DGEHRD, DORGHR, DHSEQR, DTREVC, DHSEIN, and DORMHR SEP (Symmetric Eigenvalue Problem): Test DSYTRD, DORGTR, DSTEQR, DSTERF, DSTEIN, DSTEDC, and drivers DSYEV(X), DSBEV(X), DSPEV(X), DSTEV(X), DSYEVD, DSBEVD, DSPEVD, DSTEVD SVD (Singular Value Decomposition): Test DGEBRD, DORGBR, DBDSQR, DBDSDC and the drivers DGESVD, DGESDD DEV (Nonsymmetric Eigenvalue/eigenvector Driver): Test DGEEV DES (Nonsymmetric Schur form Driver): Test DGEES DVX (Nonsymmetric Eigenvalue/eigenvector Expert Driver): Test DGEEVX DSX (Nonsymmetric Schur form Expert Driver): Test DGEESX DGG (Generalized Nonsymmetric Eigenvalue Problem): Test DGGHD3, DGGBAL, DGGBAK, DHGEQZ, and DTGEVC DGS (Generalized Nonsymmetric Schur form Driver): Test DGGES DGV (Generalized Nonsymmetric Eigenvalue/eigenvector Driver): Test DGGEV DGX (Generalized Nonsymmetric Schur form Expert Driver): Test DGGESX DXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver): Test DGGEVX DSG (Symmetric Generalized Eigenvalue Problem): Test DSYGST, DSYGV, DSYGVD, DSYGVX, DSPGST, DSPGV, DSPGVD, DSPGVX, DSBGST, DSBGV, DSBGVD, and DSBGVX DSB (Symmetric Band Eigenvalue Problem): Test DSBTRD DBB (Band Singular Value Decomposition): Test DGBBRD DEC (Eigencondition estimation): Test DLALN2, DLASY2, DLAEQU, DLAEXC, DTRSYL, DTREXC, DTRSNA, DTRSEN, and DLAQTR DBL (Balancing a general matrix) Test DGEBAL DBK (Back transformation on a balanced matrix) Test DGEBAK DGL (Balancing a matrix pair) Test DGGBAL DGK (Back transformation on a matrix pair) Test DGGBAK GLM (Generalized Linear Regression Model): Tests DGGGLM GQR (Generalized QR and RQ factorizations): Tests DGGQRF and DGGRQF GSV (Generalized Singular Value Decomposition): Tests DGGSVD, DGGSVP, DTGSJA, DLAGS2, DLAPLL, and DLAPMT CSD (CS decomposition): Tests DORCSD LSE (Constrained Linear Least Squares): Tests DGGLSE Each test path has a different set of inputs, but the data sets for the driver routines xEV, xES, xVX, and xSX can be concatenated in a single input file. The first line of input should contain one of the 3character path names in columns 13. The number of remaining lines depends on what is found on the first line. The number of matrix types used in testing is often controllable from the input file. The number of matrix types for each path, and the test routine that describes them, is as follows: Path name(s) Types Test routine DHS or NEP 21 DCHKHS DST or SEP 21 DCHKST (routines) 18 DDRVST (drivers) DBD or SVD 16 DCHKBD (routines) 5 DDRVBD (drivers) DEV 21 DDRVEV DES 21 DDRVES DVX 21 DDRVVX DSX 21 DDRVSX DGG 26 DCHKGG (routines) DGS 26 DDRGES DGX 5 DDRGSX DGV 26 DDRGEV DXV 2 DDRGVX DSG 21 DDRVSG DSB 15 DCHKSB DBB 15 DCHKBB DEC  DCHKEC DBL  DCHKBL DBK  DCHKBK DGL  DCHKGL DGK  DCHKGK GLM 8 DCKGLM GQR 8 DCKGQR GSV 8 DCKGSV CSD 3 DCKCSD LSE 8 DCKLSE  NEP input file: line 2: NN, INTEGER Number of values of N. line 3: NVAL, INTEGER array, dimension (NN) The values for the matrix dimension N. line 4: NPARMS, INTEGER Number of values of the parameters NB, NBMIN, NX, NS, and MAXB. line 5: NBVAL, INTEGER array, dimension (NPARMS) The values for the blocksize NB. line 6: NBMIN, INTEGER array, dimension (NPARMS) The values for the minimum blocksize NBMIN. line 7: NXVAL, INTEGER array, dimension (NPARMS) The values for the crossover point NX. line 8: INMIN, INTEGER array, dimension (NPARMS) LAHQR vs TTQRE crossover point, >= 11 line 9: INWIN, INTEGER array, dimension (NPARMS) recommended deflation window size line 10: INIBL, INTEGER array, dimension (NPARMS) nibble crossover point line 11: ISHFTS, INTEGER array, dimension (NPARMS) number of simultaneous shifts) line 12: IACC22, INTEGER array, dimension (NPARMS) select structured matrix multiply: 0, 1 or 2) line 13: THRESH Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. To have all of the test ratios printed, use THRESH = 0.0 . line 14: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 14 was 2: line 15: INTEGER array, dimension (4) Four integer values for the random number seed. lines 15EOF: The remaining lines occur in sets of 1 or 2 and allow the user to specify the matrix types. Each line contains a 3character path name in columns 13, and the number of matrix types must be the first nonblank item in columns 480. If the number of matrix types is at least 1 but is less than the maximum number of possible types, a second line will be read to get the numbers of the matrix types to be used. For example, NEP 21 requests all of the matrix types for the nonsymmetric eigenvalue problem, while NEP 4 9 10 11 12 requests only matrices of type 9, 10, 11, and 12. The valid 3character path names are 'NEP' or 'SHS' for the nonsymmetric eigenvalue routines.  SEP or DSG input file: line 2: NN, INTEGER Number of values of N. line 3: NVAL, INTEGER array, dimension (NN) The values for the matrix dimension N. line 4: NPARMS, INTEGER Number of values of the parameters NB, NBMIN, and NX. line 5: NBVAL, INTEGER array, dimension (NPARMS) The values for the blocksize NB. line 6: NBMIN, INTEGER array, dimension (NPARMS) The values for the minimum blocksize NBMIN. line 7: NXVAL, INTEGER array, dimension (NPARMS) The values for the crossover point NX. line 8: THRESH Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 9: TSTCHK, LOGICAL Flag indicating whether or not to test the LAPACK routines. line 10: TSTDRV, LOGICAL Flag indicating whether or not to test the driver routines. line 11: TSTERR, LOGICAL Flag indicating whether or not to test the error exits for the LAPACK routines and driver routines. line 12: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 12 was 2: line 13: INTEGER array, dimension (4) Four integer values for the random number seed. lines 13EOF: Lines specifying matrix types, as for NEP. The 3character path names are 'SEP' or 'SST' for the symmetric eigenvalue routines and driver routines, and 'DSG' for the routines for the symmetric generalized eigenvalue problem.  SVD input file: line 2: NN, INTEGER Number of values of M and N. line 3: MVAL, INTEGER array, dimension (NN) The values for the matrix row dimension M. line 4: NVAL, INTEGER array, dimension (NN) The values for the matrix column dimension N. line 5: NPARMS, INTEGER Number of values of the parameter NB, NBMIN, NX, and NRHS. line 6: NBVAL, INTEGER array, dimension (NPARMS) The values for the blocksize NB. line 7: NBMIN, INTEGER array, dimension (NPARMS) The values for the minimum blocksize NBMIN. line 8: NXVAL, INTEGER array, dimension (NPARMS) The values for the crossover point NX. line 9: NSVAL, INTEGER array, dimension (NPARMS) The values for the number of right hand sides NRHS. line 10: THRESH Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 11: TSTCHK, LOGICAL Flag indicating whether or not to test the LAPACK routines. line 12: TSTDRV, LOGICAL Flag indicating whether or not to test the driver routines. line 13: TSTERR, LOGICAL Flag indicating whether or not to test the error exits for the LAPACK routines and driver routines. line 14: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 14 was 2: line 15: INTEGER array, dimension (4) Four integer values for the random number seed. lines 15EOF: Lines specifying matrix types, as for NEP. The 3character path names are 'SVD' or 'SBD' for both the SVD routines and the SVD driver routines.  DEV and DES data files: line 1: 'DEV' or 'DES' in columns 1 to 3. line 2: NSIZES, INTEGER Number of sizes of matrices to use. Should be at least 0 and at most 20. If NSIZES = 0, no testing is done (although the remaining 3 lines are still read). line 3: NN, INTEGER array, dimension(NSIZES) Dimensions of matrices to be tested. line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs These integer parameters determine how blocking is done (see ILAENV for details) NB : block size NBMIN : minimum block size NX : minimum dimension for blocking NS : number of shifts in xHSEQR NBCOL : minimum column dimension for blocking line 5: THRESH, REAL The test threshold against which computed residuals are compared. Should generally be in the range from 10. to 20. If it is 0., all test case data will be printed. line 6: TSTERR, LOGICAL Flag indicating whether or not to test the error exits. line 7: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 7 was 2: line 8: INTEGER array, dimension (4) Four integer values for the random number seed. lines 9 and following: Lines specifying matrix types, as for NEP. The 3character path name is 'DEV' to test SGEEV, or 'DES' to test SGEES.  The DVX data has two parts. The first part is identical to DEV, and the second part consists of test matrices with precomputed solutions. line 1: 'DVX' in columns 13. line 2: NSIZES, INTEGER If NSIZES = 0, no testing of randomly generated examples is done, but any precomputed examples are tested. line 3: NN, INTEGER array, dimension(NSIZES) line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs line 5: THRESH, REAL line 6: TSTERR, LOGICAL line 7: NEWSD, INTEGER If line 7 was 2: line 8: INTEGER array, dimension (4) lines 9 and following: The first line contains 'DVX' in columns 13 followed by the number of matrix types, possibly with a second line to specify certain matrix types. If the number of matrix types = 0, no testing of randomly generated examples is done, but any precomputed examples are tested. remaining lines : Each matrix is stored on 1+2*N lines, where N is its dimension. The first line contains the dimension (a single integer). The next N lines contain the matrix, one row per line. The last N lines correspond to each eigenvalue. Each of these last N lines contains 4 real values: the real part of the eigenvalue, the imaginary part of the eigenvalue, the reciprocal condition number of the eigenvalues, and the reciprocal condition number of the eigenvector. The end of data is indicated by dimension N=0. Even if no data is to be tested, there must be at least one line containing N=0.  The DSX data is like DVX. The first part is identical to DEV, and the second part consists of test matrices with precomputed solutions. line 1: 'DSX' in columns 13. line 2: NSIZES, INTEGER If NSIZES = 0, no testing of randomly generated examples is done, but any precomputed examples are tested. line 3: NN, INTEGER array, dimension(NSIZES) line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs line 5: THRESH, REAL line 6: TSTERR, LOGICAL line 7: NEWSD, INTEGER If line 7 was 2: line 8: INTEGER array, dimension (4) lines 9 and following: The first line contains 'DSX' in columns 13 followed by the number of matrix types, possibly with a second line to specify certain matrix types. If the number of matrix types = 0, no testing of randomly generated examples is done, but any precomputed examples are tested. remaining lines : Each matrix is stored on 3+N lines, where N is its dimension. The first line contains the dimension N and the dimension M of an invariant subspace. The second line contains M integers, identifying the eigenvalues in the invariant subspace (by their position in a list of eigenvalues ordered by increasing real part). The next N lines contain the matrix. The last line contains the reciprocal condition number for the average of the selected eigenvalues, and the reciprocal condition number for the corresponding right invariant subspace. The end of data is indicated by a line containing N=0 and M=0. Even if no data is to be tested, there must be at least one line containing N=0 and M=0.  DGG input file: line 2: NN, INTEGER Number of values of N. line 3: NVAL, INTEGER array, dimension (NN) The values for the matrix dimension N. line 4: NPARMS, INTEGER Number of values of the parameters NB, NBMIN, NS, MAXB, and NBCOL. line 5: NBVAL, INTEGER array, dimension (NPARMS) The values for the blocksize NB. line 6: NBMIN, INTEGER array, dimension (NPARMS) The values for NBMIN, the minimum row dimension for blocks. line 7: NSVAL, INTEGER array, dimension (NPARMS) The values for the number of shifts. line 8: MXBVAL, INTEGER array, dimension (NPARMS) The values for MAXB, used in determining minimum blocksize. line 9: IACC22, INTEGER array, dimension (NPARMS) select structured matrix multiply: 1 or 2) line 10: NBCOL, INTEGER array, dimension (NPARMS) The values for NBCOL, the minimum column dimension for blocks. line 11: THRESH Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 12: TSTCHK, LOGICAL Flag indicating whether or not to test the LAPACK routines. line 13: TSTDRV, LOGICAL Flag indicating whether or not to test the driver routines. line 14: TSTERR, LOGICAL Flag indicating whether or not to test the error exits for the LAPACK routines and driver routines. line 15: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 15 was 2: line 16: INTEGER array, dimension (4) Four integer values for the random number seed. lines 17EOF: Lines specifying matrix types, as for NEP. The 3character path name is 'DGG' for the generalized eigenvalue problem routines and driver routines.  DGS and DGV input files: line 1: 'DGS' or 'DGV' in columns 1 to 3. line 2: NN, INTEGER Number of values of N. line 3: NVAL, INTEGER array, dimension(NN) Dimensions of matrices to be tested. line 4: NB, NBMIN, NX, NS, NBCOL, INTEGERs These integer parameters determine how blocking is done (see ILAENV for details) NB : block size NBMIN : minimum block size NX : minimum dimension for blocking NS : number of shifts in xHGEQR NBCOL : minimum column dimension for blocking line 5: THRESH, REAL The test threshold against which computed residuals are compared. Should generally be in the range from 10. to 20. If it is 0., all test case data will be printed. line 6: TSTERR, LOGICAL Flag indicating whether or not to test the error exits. line 7: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 17 was 2: line 7: INTEGER array, dimension (4) Four integer values for the random number seed. lines 7EOF: Lines specifying matrix types, as for NEP. The 3character path name is 'DGS' for the generalized eigenvalue problem routines and driver routines.  DXV input files: line 1: 'DXV' in columns 1 to 3. line 2: N, INTEGER Value of N. line 3: NB, NBMIN, NX, NS, NBCOL, INTEGERs These integer parameters determine how blocking is done (see ILAENV for details) NB : block size NBMIN : minimum block size NX : minimum dimension for blocking NS : number of shifts in xHGEQR NBCOL : minimum column dimension for blocking line 4: THRESH, REAL The test threshold against which computed residuals are compared. Should generally be in the range from 10. to 20. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 5: TSTERR, LOGICAL Flag indicating whether or not to test the error exits for the LAPACK routines and driver routines. line 6: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 6 was 2: line 7: INTEGER array, dimension (4) Four integer values for the random number seed. If line 2 was 0: line 7EOF: Precomputed examples are tested. remaining lines : Each example is stored on 3+2*N lines, where N is its dimension. The first line contains the dimension (a single integer). The next N lines contain the matrix A, one row per line. The next N lines contain the matrix B. The next line contains the reciprocals of the eigenvalue condition numbers. The last line contains the reciprocals of the eigenvector condition numbers. The end of data is indicated by dimension N=0. Even if no data is to be tested, there must be at least one line containing N=0.  DGX input files: line 1: 'DGX' in columns 1 to 3. line 2: N, INTEGER Value of N. line 3: NB, NBMIN, NX, NS, NBCOL, INTEGERs These integer parameters determine how blocking is done (see ILAENV for details) NB : block size NBMIN : minimum block size NX : minimum dimension for blocking NS : number of shifts in xHGEQR NBCOL : minimum column dimension for blocking line 4: THRESH, REAL The test threshold against which computed residuals are compared. Should generally be in the range from 10. to 20. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 5: TSTERR, LOGICAL Flag indicating whether or not to test the error exits for the LAPACK routines and driver routines. line 6: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 6 was 2: line 7: INTEGER array, dimension (4) Four integer values for the random number seed. If line 2 was 0: line 7EOF: Precomputed examples are tested. remaining lines : Each example is stored on 3+2*N lines, where N is its dimension. The first line contains the dimension (a single integer). The next line contains an integer k such that only the last k eigenvalues will be selected and appear in the leading diagonal blocks of $A$ and $B$. The next N lines contain the matrix A, one row per line. The next N lines contain the matrix B. The last line contains the reciprocal of the eigenvalue cluster condition number and the reciprocal of the deflating subspace (associated with the selected eigencluster) condition number. The end of data is indicated by dimension N=0. Even if no data is to be tested, there must be at least one line containing N=0.  DSB input file: line 2: NN, INTEGER Number of values of N. line 3: NVAL, INTEGER array, dimension (NN) The values for the matrix dimension N. line 4: NK, INTEGER Number of values of K. line 5: KVAL, INTEGER array, dimension (NK) The values for the matrix dimension K. line 6: THRESH Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 7: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 7 was 2: line 8: INTEGER array, dimension (4) Four integer values for the random number seed. lines 8EOF: Lines specifying matrix types, as for NEP. The 3character path name is 'DSB'.  DBB input file: line 2: NN, INTEGER Number of values of M and N. line 3: MVAL, INTEGER array, dimension (NN) The values for the matrix row dimension M. line 4: NVAL, INTEGER array, dimension (NN) The values for the matrix column dimension N. line 4: NK, INTEGER Number of values of K. line 5: KVAL, INTEGER array, dimension (NK) The values for the matrix bandwidth K. line 6: NPARMS, INTEGER Number of values of the parameter NRHS line 7: NSVAL, INTEGER array, dimension (NPARMS) The values for the number of right hand sides NRHS. line 8: THRESH Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 9: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 9 was 2: line 10: INTEGER array, dimension (4) Four integer values for the random number seed. lines 10EOF: Lines specifying matrix types, as for SVD. The 3character path name is 'DBB'.  DEC input file: line 2: THRESH, REAL Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. lines 3EOF: Input for testing the eigencondition routines consists of a set of specially constructed test cases and their solutions. The data format is not intended to be modified by the user.  DBL and DBK input files: line 1: 'DBL' in columns 13 to test SGEBAL, or 'DBK' in columns 13 to test SGEBAK. The remaining lines consist of specially constructed test cases.  DGL and DGK input files: line 1: 'DGL' in columns 13 to test DGGBAL, or 'DGK' in columns 13 to test DGGBAK. The remaining lines consist of specially constructed test cases.  GLM data file: line 1: 'GLM' in columns 1 to 3. line 2: NN, INTEGER Number of values of M, P, and N. line 3: MVAL, INTEGER array, dimension(NN) Values of M (row dimension). line 4: PVAL, INTEGER array, dimension(NN) Values of P (row dimension). line 5: NVAL, INTEGER array, dimension(NN) Values of N (column dimension), note M <= N <= M+P. line 6: THRESH, REAL Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 7: TSTERR, LOGICAL Flag indicating whether or not to test the error exits for the LAPACK routines and driver routines. line 8: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 8 was 2: line 9: INTEGER array, dimension (4) Four integer values for the random number seed. lines 9EOF: Lines specifying matrix types, as for NEP. The 3character path name is 'GLM' for the generalized linear regression model routines.  GQR data file: line 1: 'GQR' in columns 1 to 3. line 2: NN, INTEGER Number of values of M, P, and N. line 3: MVAL, INTEGER array, dimension(NN) Values of M. line 4: PVAL, INTEGER array, dimension(NN) Values of P. line 5: NVAL, INTEGER array, dimension(NN) Values of N. line 6: THRESH, REAL Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 7: TSTERR, LOGICAL Flag indicating whether or not to test the error exits for the LAPACK routines and driver routines. line 8: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 8 was 2: line 9: INTEGER array, dimension (4) Four integer values for the random number seed. lines 9EOF: Lines specifying matrix types, as for NEP. The 3character path name is 'GQR' for the generalized QR and RQ routines.  GSV data file: line 1: 'GSV' in columns 1 to 3. line 2: NN, INTEGER Number of values of M, P, and N. line 3: MVAL, INTEGER array, dimension(NN) Values of M (row dimension). line 4: PVAL, INTEGER array, dimension(NN) Values of P (row dimension). line 5: NVAL, INTEGER array, dimension(NN) Values of N (column dimension). line 6: THRESH, REAL Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 7: TSTERR, LOGICAL Flag indicating whether or not to test the error exits for the LAPACK routines and driver routines. line 8: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 8 was 2: line 9: INTEGER array, dimension (4) Four integer values for the random number seed. lines 9EOF: Lines specifying matrix types, as for NEP. The 3character path name is 'GSV' for the generalized SVD routines.  CSD data file: line 1: 'CSD' in columns 1 to 3. line 2: NM, INTEGER Number of values of M, P, and N. line 3: MVAL, INTEGER array, dimension(NM) Values of M (row and column dimension of orthogonal matrix). line 4: PVAL, INTEGER array, dimension(NM) Values of P (row dimension of topleft block). line 5: NVAL, INTEGER array, dimension(NM) Values of N (column dimension of topleft block). line 6: THRESH, REAL Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 7: TSTERR, LOGICAL Flag indicating whether or not to test the error exits for the LAPACK routines and driver routines. line 8: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 8 was 2: line 9: INTEGER array, dimension (4) Four integer values for the random number seed. lines 9EOF: Lines specifying matrix types, as for NEP. The 3character path name is 'CSD' for the CSD routine.  LSE data file: line 1: 'LSE' in columns 1 to 3. line 2: NN, INTEGER Number of values of M, P, and N. line 3: MVAL, INTEGER array, dimension(NN) Values of M. line 4: PVAL, INTEGER array, dimension(NN) Values of P. line 5: NVAL, INTEGER array, dimension(NN) Values of N, note P <= N <= P+M. line 6: THRESH, REAL Threshold value for the test ratios. Information will be printed about each test for which the test ratio is greater than or equal to the threshold. line 7: TSTERR, LOGICAL Flag indicating whether or not to test the error exits for the LAPACK routines and driver routines. line 8: NEWSD, INTEGER A code indicating how to set the random number seed. = 0: Set the seed to a default value before each run = 1: Initialize the seed to a default value only before the first run = 2: Like 1, but use the seed values on the next line If line 8 was 2: line 9: INTEGER array, dimension (4) Four integer values for the random number seed. lines 9EOF: Lines specifying matrix types, as for NEP. The 3character path name is 'GSV' for the generalized SVD routines.  NMAX is currently set to 132 and must be at least 12 for some of the precomputed examples, and LWORK = NMAX*(5*NMAX+5)+1 in the parameter statements below. For SVD, we assume NRHS may be as big as N. The parameter NEED is set to 14 to allow for 14 NbyN matrices for DGG.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine dchkgg (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, logical TSTDIF, double precision THRSHN, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) H, double precision, dimension( lda, * ) T, double precision, dimension( lda, * ) S1, double precision, dimension( lda, * ) S2, double precision, dimension( lda, * ) P1, double precision, dimension( lda, * ) P2, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldu, * ) V, double precision, dimension( ldu, * ) Q, double precision, dimension( ldu, * ) Z, double precision, dimension( * ) ALPHR1, double precision, dimension( * ) ALPHI1, double precision, dimension( * ) BETA1, double precision, dimension( * ) ALPHR3, double precision, dimension( * ) ALPHI3, double precision, dimension( * ) BETA3, double precision, dimension( ldu, * ) EVECTL, double precision, dimension( ldu, * ) EVECTR, double precision, dimension( * ) WORK, integer LWORK, logical, dimension( * ) LLWORK, double precision, dimension( 15 ) RESULT, integer INFO)
DCHKGG
Purpose:

DCHKGG checks the nonsymmetric generalized eigenvalue problem routines. T T T DGGHRD factors A and B as U H V and U T V , where means transpose, H is hessenberg, T is triangular and U and V are orthogonal. T T DHGEQZ factors H and T as Q S Z and Q P Z , where P is upper triangular, S is in generalized Schur form (block upper triangular, with 1x1 and 2x2 blocks on the diagonal, the 2x2 blocks corresponding to complex conjugate pairs of generalized eigenvalues), and Q and Z are orthogonal. It also computes the generalized eigenvalues (alpha(1),beta(1)),...,(alpha(n),beta(n)), where alpha(j)=S(j,j) and beta(j)=P(j,j)  thus, w(j) = alpha(j)/beta(j) is a root of the generalized eigenvalue problem det( A  w(j) B ) = 0 and m(j) = beta(j)/alpha(j) is a root of the essentially equivalent problem det( m(j) A  B ) = 0 DTGEVC computes the matrix L of left eigenvectors and the matrix R of right eigenvectors for the matrix pair ( S, P ). In the description below, l and r are left and right eigenvectors corresponding to the generalized eigenvalues (alpha,beta). When DCHKGG is called, a number of matrix "sizes" ("n's") and a number of matrix "types" are specified. For each size ("n") and each type of matrix, one matrix will be generated and used to test the nonsymmetric eigenroutines. For each matrix, 15 tests will be performed. The first twelve "test ratios" should be small  O(1). They will be compared with the threshold THRESH: T (1)  A  U H V  / ( A n ulp ) T (2)  B  U T V  / ( B n ulp ) T (3)  I  UU  / ( n ulp ) T (4)  I  VV  / ( n ulp ) T (5)  H  Q S Z  / ( H n ulp ) T (6)  T  Q P Z  / ( T n ulp ) T (7)  I  QQ  / ( n ulp ) T (8)  I  ZZ  / ( n ulp ) (9) max over all left eigenvalue/vector pairs (beta/alpha,l) of  l**H * (beta S  alpha P)  / ( ulp max( beta S, alpha P ) ) (10) max over all left eigenvalue/vector pairs (beta/alpha,l') of T  l'**H * (beta H  alpha T)  / ( ulp max( beta H, alpha T ) ) where the eigenvectors l' are the result of passing Q to DTGEVC and back transforming (HOWMNY='B'). (11) max over all right eigenvalue/vector pairs (beta/alpha,r) of  (beta S  alpha T) r  / ( ulp max( beta S, alpha T ) ) (12) max over all right eigenvalue/vector pairs (beta/alpha,r') of  (beta H  alpha T) r'  / ( ulp max( beta H, alpha T ) ) where the eigenvectors r' are the result of passing Z to DTGEVC and back transforming (HOWMNY='B'). The last three test ratios will usually be small, but there is no mathematical requirement that they be so. They are therefore compared with THRESH only if TSTDIF is .TRUE. (13)  S(Q,Z computed)  S(Q,Z not computed)  / ( S ulp ) (14)  P(Q,Z computed)  P(Q,Z not computed)  / ( P ulp ) (15) max( alpha(Q,Z computed)  alpha(Q,Z not computed)/S , beta(Q,Z computed)  beta(Q,Z not computed)/P ) / ulp In addition, the normalization of L and R are checked, and compared with the threshold THRSHN. Test Matrices   The sizes of the test matrices are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) ( 0, 0 ) (a pair of zero matrices) (2) ( I, 0 ) (an identity and a zero matrix) (3) ( 0, I ) (an identity and a zero matrix) (4) ( I, I ) (a pair of identity matrices) t t (5) ( J , J ) (a pair of transposed Jordan blocks) t ( I 0 ) (6) ( X, Y ) where X = ( J 0 ) and Y = ( t ) ( 0 I ) ( 0 J ) and I is a k x k identity and J a (k+1)x(k+1) Jordan block; k=(N1)/2 (7) ( D, I ) where D is diag( 0, 1,..., N1 ) (a diagonal matrix with those diagonal entries.) (8) ( I, D ) (9) ( big*D, small*I ) where "big" is near overflow and small=1/big (10) ( small*D, big*I ) (11) ( big*I, small*D ) (12) ( small*I, big*D ) (13) ( big*D, big*I ) (14) ( small*D, small*I ) (15) ( D1, D2 ) where D1 is diag( 0, 0, 1, ..., N3, 0 ) and D2 is diag( 0, N3, N4,..., 1, 0, 0 ) t t (16) U ( J , J ) V where U and V are random orthogonal matrices. (17) U ( T1, T2 ) V where T1 and T2 are upper triangular matrices with random O(1) entries above the diagonal and diagonal entries diag(T1) = ( 0, 0, 1, ..., N3, 0 ) and diag(T2) = ( 0, N3, N4,..., 1, 0, 0 ) (18) U ( T1, T2 ) V diag(T1) = ( 0, 0, 1, 1, s, ..., s, 0 ) diag(T2) = ( 0, 1, 0, 1,..., 1, 0 ) s = machine precision. (19) U ( T1, T2 ) V diag(T1)=( 0,0,1,1, 1d, ..., 1(N5)*d=s, 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 ) N5 (20) U ( T1, T2 ) V diag(T1)=( 0, 0, 1, 1, a, ..., a =s, 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 ) (21) U ( T1, T2 ) V diag(T1)=( 0, 0, 1, r1, r2, ..., r(N4), 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 ) where r1,..., r(N4) are random. (22) U ( big*T1, small*T2 ) V diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (23) U ( small*T1, big*T2 ) V diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (24) U ( small*T1, small*T2 ) V diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (25) U ( big*T1, big*T2 ) V diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (26) U ( T1, T2 ) V where T1 and T2 are random uppertriangular matrices.
Parameters:

NSIZES
NSIZES is INTEGER The number of sizes of matrices to use. If it is zero, DCHKGG does nothing. It must be at least zero.
NNNN is INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. The values must be at least zero.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DCHKGG does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DCHKGG to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
TSTDIFTSTDIF is LOGICAL Specifies whether test ratios 1315 will be computed and compared with THRESH. = .FALSE.: Only test ratios 112 will be computed and tested. Ratios 1315 will be set to zero. = .TRUE.: All the test ratios 115 will be computed and tested.
THRSHNTHRSHN is DOUBLE PRECISION Threshold for reporting eigenvector normalization error. If the normalization of any eigenvector differs from 1 by more than THRSHN*ulp, then a special error message will be printed. (This is handled separately from the other tests, since only a compiler or programming error should cause an error message, at least if THRSHN is at least 510.)
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.)
AA is DOUBLE PRECISION array, dimension (LDA, max(NN)) Used to hold the original A matrix. Used as input only if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and DOTYPE(MAXTYP+1)=.TRUE.
LDALDA is INTEGER The leading dimension of A, B, H, T, S1, P1, S2, and P2. It must be at least 1 and at least max( NN ).
BB is DOUBLE PRECISION array, dimension (LDA, max(NN)) Used to hold the original B matrix. Used as input only if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and DOTYPE(MAXTYP+1)=.TRUE.
HH is DOUBLE PRECISION array, dimension (LDA, max(NN)) The upper Hessenberg matrix computed from A by DGGHRD.
TT is DOUBLE PRECISION array, dimension (LDA, max(NN)) The upper triangular matrix computed from B by DGGHRD.
S1S1 is DOUBLE PRECISION array, dimension (LDA, max(NN)) The Schur (block upper triangular) matrix computed from H by DHGEQZ when Q and Z are also computed.
S2S2 is DOUBLE PRECISION array, dimension (LDA, max(NN)) The Schur (block upper triangular) matrix computed from H by DHGEQZ when Q and Z are not computed.
P1P1 is DOUBLE PRECISION array, dimension (LDA, max(NN)) The upper triangular matrix computed from T by DHGEQZ when Q and Z are also computed.
P2P2 is DOUBLE PRECISION array, dimension (LDA, max(NN)) The upper triangular matrix computed from T by DHGEQZ when Q and Z are not computed.
UU is DOUBLE PRECISION array, dimension (LDU, max(NN)) The (left) orthogonal matrix computed by DGGHRD.
LDULDU is INTEGER The leading dimension of U, V, Q, Z, EVECTL, and EVEZTR. It must be at least 1 and at least max( NN ).
VV is DOUBLE PRECISION array, dimension (LDU, max(NN)) The (right) orthogonal matrix computed by DGGHRD.
QQ is DOUBLE PRECISION array, dimension (LDU, max(NN)) The (left) orthogonal matrix computed by DHGEQZ.
ZZ is DOUBLE PRECISION array, dimension (LDU, max(NN)) The (left) orthogonal matrix computed by DHGEQZ.
ALPHR1ALPHR1 is DOUBLE PRECISION array, dimension (max(NN))
ALPHI1ALPHI1 is DOUBLE PRECISION array, dimension (max(NN))
BETA1BETA1 is DOUBLE PRECISION array, dimension (max(NN)) The generalized eigenvalues of (A,B) computed by DHGEQZ when Q, Z, and the full Schur matrices are computed. On exit, ( ALPHR1(k)+ALPHI1(k)*i ) / BETA1(k) is the kth generalized eigenvalue of the matrices in A and B.
ALPHR3ALPHR3 is DOUBLE PRECISION array, dimension (max(NN))
ALPHI3ALPHI3 is DOUBLE PRECISION array, dimension (max(NN))
BETA3BETA3 is DOUBLE PRECISION array, dimension (max(NN))
EVECTLEVECTL is DOUBLE PRECISION array, dimension (LDU, max(NN)) The (block lower triangular) left eigenvector matrix for the matrices in S1 and P1. (See DTGEVC for the format.)
EVECTREVECTR is DOUBLE PRECISION array, dimension (LDU, max(NN)) The (block upper triangular) right eigenvector matrix for the matrices in S1 and P1. (See DTGEVC for the format.)
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The number of entries in WORK. This must be at least max( 2 * N**2, 6*N, 1 ), for all N=NN(j).
LLWORKLLWORK is LOGICAL array, dimension (max(NN))
RESULTRESULT is DOUBLE PRECISION array, dimension (15) The values computed by the tests described above. The values are currently limited to 1/ulp, to avoid overflow.
INFOINFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value > 0: A routine returned an error code. INFO is the absolute value of the INFO value returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine dchkgk (integer NIN, integer NOUT)
DCHKGK
Purpose:

DCHKGK tests DGGBAK, a routine for backward balancing of a matrix pair (A, B).
Parameters:

NIN
NIN is INTEGER The logical unit number for input. NIN > 0.
NOUTNOUT is INTEGER The logical unit number for output. NOUT > 0.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dchkgl (integer NIN, integer NOUT)
DCHKGL
Purpose:

DCHKGL tests DGGBAL, a routine for balancing a matrix pair (A, B).
Parameters:

NIN
NIN is INTEGER The logical unit number for input. NIN > 0.
NOUTNOUT is INTEGER The logical unit number for output. NOUT > 0.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dchkhs (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( lda, * ) T1, double precision, dimension( lda, * ) T2, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldu, * ) Z, double precision, dimension( ldu, * ) UZ, double precision, dimension( * ) WR1, double precision, dimension( * ) WI1, double precision, dimension( * ) WR2, double precision, dimension( * ) WI2, double precision, dimension( * ) WR3, double precision, dimension( * ) WI3, double precision, dimension( ldu, * ) EVECTL, double precision, dimension( ldu, * ) EVECTR, double precision, dimension( ldu, * ) EVECTY, double precision, dimension( ldu, * ) EVECTX, double precision, dimension( ldu, * ) UU, double precision, dimension( * ) TAU, double precision, dimension( * ) WORK, integer NWORK, integer, dimension( * ) IWORK, logical, dimension( * ) SELECT, double precision, dimension( 14 ) RESULT, integer INFO)
DCHKHS
Purpose:

DCHKHS checks the nonsymmetric eigenvalue problem routines. DGEHRD factors A as U H U' , where ' means transpose, H is hessenberg, and U is an orthogonal matrix. DORGHR generates the orthogonal matrix U. DORMHR multiplies a matrix by the orthogonal matrix U. DHSEQR factors H as Z T Z' , where Z is orthogonal and T is "quasitriangular", and the eigenvalue vector W. DTREVC computes the left and right eigenvector matrices L and R for T. DHSEIN computes the left and right eigenvector matrices Y and X for H, using inverse iteration. When DCHKHS is called, a number of matrix "sizes" ("n's") and a number of matrix "types" are specified. For each size ("n") and each type of matrix, one matrix will be generated and used to test the nonsymmetric eigenroutines. For each matrix, 14 tests will be performed: (1)  A  U H U**T  / ( A n ulp ) (2)  I  UU**T  / ( n ulp ) (3)  H  Z T Z**T  / ( H n ulp ) (4)  I  ZZ**T  / ( n ulp ) (5)  A  UZ H (UZ)**T  / ( A n ulp ) (6)  I  UZ (UZ)**T  / ( n ulp ) (7)  T(Z computed)  T(Z not computed)  / ( T ulp ) (8)  W(Z computed)  W(Z not computed)  / ( W ulp ) (9)  TR  RW  / ( T R ulp ) (10)  L**H T  W**H L  / ( T L ulp ) (11)  HX  XW  / ( H X ulp ) (12)  Y**H H  W**H Y  / ( H Y ulp ) (13)  AX  XW  / ( A X ulp ) (14)  Y**H A  W**H Y  / ( A Y ulp ) The "sizes" are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) The zero matrix. (2) The identity matrix. (3) A (transposed) Jordan block, with 1's on the diagonal. (4) A diagonal matrix with evenly spaced entries 1, ..., ULP and random signs. (ULP = (first number larger than 1)  1 ) (5) A diagonal matrix with geometrically spaced entries 1, ..., ULP and random signs. (6) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP and random signs. (7) Same as (4), but multiplied by SQRT( overflow threshold ) (8) Same as (4), but multiplied by SQRT( underflow threshold ) (9) A matrix of the form U' T U, where U is orthogonal and T has evenly spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (10) A matrix of the form U' T U, where U is orthogonal and T has geometrically spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (11) A matrix of the form U' T U, where U is orthogonal and T has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (12) A matrix of the form U' T U, where U is orthogonal and T has real or complex conjugate paired eigenvalues randomly chosen from ( ULP, 1 ) and random O(1) entries in the upper triangle. (13) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (14) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has geometrically spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (15) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (16) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has real or complex conjugate paired eigenvalues randomly chosen from ( ULP, 1 ) and random O(1) entries in the upper triangle. (17) Same as (16), but multiplied by SQRT( overflow threshold ) (18) Same as (16), but multiplied by SQRT( underflow threshold ) (19) Nonsymmetric matrix with random entries chosen from (1,1). (20) Same as (19), but multiplied by SQRT( overflow threshold ) (21) Same as (19), but multiplied by SQRT( underflow threshold )
NSIZES  INTEGER The number of sizes of matrices to use. If it is zero, DCHKHS does nothing. It must be at least zero. Not modified. NN  INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. The values must be at least zero. Not modified. NTYPES  INTEGER The number of elements in DOTYPE. If it is zero, DCHKHS does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. . Not modified. DOTYPE  LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored. Not modified. ISEED  INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DCHKHS to continue the same random number sequence. Modified. THRESH  DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero. Not modified. NOUNIT  INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.) Not modified. A  DOUBLE PRECISION array, dimension (LDA,max(NN)) Used to hold the matrix whose eigenvalues are to be computed. On exit, A contains the last matrix actually used. Modified. LDA  INTEGER The leading dimension of A, H, T1 and T2. It must be at least 1 and at least max( NN ). Not modified. H  DOUBLE PRECISION array, dimension (LDA,max(NN)) The upper hessenberg matrix computed by DGEHRD. On exit, H contains the Hessenberg form of the matrix in A. Modified. T1  DOUBLE PRECISION array, dimension (LDA,max(NN)) The Schur (="quasitriangular") matrix computed by DHSEQR if Z is computed. On exit, T1 contains the Schur form of the matrix in A. Modified. T2  DOUBLE PRECISION array, dimension (LDA,max(NN)) The Schur matrix computed by DHSEQR when Z is not computed. This should be identical to T1. Modified. LDU  INTEGER The leading dimension of U, Z, UZ and UU. It must be at least 1 and at least max( NN ). Not modified. U  DOUBLE PRECISION array, dimension (LDU,max(NN)) The orthogonal matrix computed by DGEHRD. Modified. Z  DOUBLE PRECISION array, dimension (LDU,max(NN)) The orthogonal matrix computed by DHSEQR. Modified. UZ  DOUBLE PRECISION array, dimension (LDU,max(NN)) The product of U times Z. Modified. WR1  DOUBLE PRECISION array, dimension (max(NN)) WI1  DOUBLE PRECISION array, dimension (max(NN)) The real and imaginary parts of the eigenvalues of A, as computed when Z is computed. On exit, WR1 + WI1*i are the eigenvalues of the matrix in A. Modified. WR2  DOUBLE PRECISION array, dimension (max(NN)) WI2  DOUBLE PRECISION array, dimension (max(NN)) The real and imaginary parts of the eigenvalues of A, as computed when T is computed but not Z. On exit, WR2 + WI2*i are the eigenvalues of the matrix in A. Modified. WR3  DOUBLE PRECISION array, dimension (max(NN)) WI3  DOUBLE PRECISION array, dimension (max(NN)) Like WR1, WI1, these arrays contain the eigenvalues of A, but those computed when DHSEQR only computes the eigenvalues, i.e., not the Schur vectors and no more of the Schur form than is necessary for computing the eigenvalues. Modified. EVECTL  DOUBLE PRECISION array, dimension (LDU,max(NN)) The (upper triangular) left eigenvector matrix for the matrix in T1. For complex conjugate pairs, the real part is stored in one row and the imaginary part in the next. Modified. EVEZTR  DOUBLE PRECISION array, dimension (LDU,max(NN)) The (upper triangular) right eigenvector matrix for the matrix in T1. For complex conjugate pairs, the real part is stored in one column and the imaginary part in the next. Modified. EVECTY  DOUBLE PRECISION array, dimension (LDU,max(NN)) The left eigenvector matrix for the matrix in H. For complex conjugate pairs, the real part is stored in one row and the imaginary part in the next. Modified. EVECTX  DOUBLE PRECISION array, dimension (LDU,max(NN)) The right eigenvector matrix for the matrix in H. For complex conjugate pairs, the real part is stored in one column and the imaginary part in the next. Modified. UU  DOUBLE PRECISION array, dimension (LDU,max(NN)) Details of the orthogonal matrix computed by DGEHRD. Modified. TAU  DOUBLE PRECISION array, dimension(max(NN)) Further details of the orthogonal matrix computed by DGEHRD. Modified. WORK  DOUBLE PRECISION array, dimension (NWORK) Workspace. Modified. NWORK  INTEGER The number of entries in WORK. NWORK >= 4*NN(j)*NN(j) + 2. IWORK  INTEGER array, dimension (max(NN)) Workspace. Modified. SELECT  LOGICAL array, dimension (max(NN)) Workspace. Modified. RESULT  DOUBLE PRECISION array, dimension (14) The values computed by the fourteen tests described above. The values are currently limited to 1/ulp, to avoid overflow. Modified. INFO  INTEGER If 0, then everything ran OK. 1: NSIZES < 0 2: Some NN(j) < 0 3: NTYPES < 0 6: THRESH < 0 9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ). 14: LDU < 1 or LDU < NMAX. 28: NWORK too small. If DLATMR, SLATMS, or SLATME returns an error code, the absolute value of it is returned. If 1, then DHSEQR could not find all the shifts. If 2, then the EISPACK code (for small blocks) failed. If >2, then 30*N iterations were not enough to find an eigenvalue or to decompose the problem. Modified.  Some Local Variables and Parameters:      ZERO, ONE Real 0 and 1. MAXTYP The number of types defined. MTEST The number of tests defined: care must be taken that (1) the size of RESULT, (2) the number of tests actually performed, and (3) MTEST agree. NTEST The number of tests performed on this matrix so far. This should be less than MTEST, and equal to it by the last test. It will be less if any of the routines being tested indicates that it could not compute the matrices that would be tested. NMAX Largest value in NN. NMATS The number of matrices generated so far. NERRS The number of tests which have exceeded THRESH so far (computed by DLAFTS). COND, CONDS, IMODE Values to be passed to the matrix generators. ANORM Norm of A; passed to matrix generators. OVFL, UNFL Overflow and underflow thresholds. ULP, ULPINV Finest relative precision and its inverse. RTOVFL, RTUNFL, RTULP, RTULPI Square roots of the previous 4 values. The following four arrays decode JTYPE: KTYPE(j) The general type (110) for type "j". KMODE(j) The MODE value to be passed to the matrix generator for type "j". KMAGN(j) The order of magnitude ( O(1), O(overflow^(1/2) ), O(underflow^(1/2) ) KCONDS(j) Selects whether CONDS is to be 1 or 1/sqrt(ulp). (0 means irrelevant.)
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2015
subroutine dchksb (integer NSIZES, integer, dimension( * ) NN, integer NWDTHS, integer, dimension( * ) KK, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) SD, double precision, dimension( * ) SE, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RESULT, integer INFO)
DCHKSB
Purpose:

DCHKSB tests the reduction of a symmetric band matrix to tridiagonal form, used with the symmetric eigenvalue problem. DSBTRD factors a symmetric band matrix A as U S U' , where ' means transpose, S is symmetric tridiagonal, and U is orthogonal. DSBTRD can use either just the lower or just the upper triangle of A; DCHKSB checks both cases. When DCHKSB is called, a number of matrix "sizes" ("n's"), a number of bandwidths ("k's"), and a number of matrix "types" are specified. For each size ("n"), each bandwidth ("k") less than or equal to "n", and each type of matrix, one matrix will be generated and used to test the symmetric banded reduction routine. For each matrix, a number of tests will be performed: (1)  A  V S V'  / ( A n ulp ) computed by DSBTRD with UPLO='U' (2)  I  UU'  / ( n ulp ) (3)  A  V S V'  / ( A n ulp ) computed by DSBTRD with UPLO='L' (4)  I  UU'  / ( n ulp ) The "sizes" are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) The zero matrix. (2) The identity matrix. (3) A diagonal matrix with evenly spaced entries 1, ..., ULP and random signs. (ULP = (first number larger than 1)  1 ) (4) A diagonal matrix with geometrically spaced entries 1, ..., ULP and random signs. (5) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP and random signs. (6) Same as (4), but multiplied by SQRT( overflow threshold ) (7) Same as (4), but multiplied by SQRT( underflow threshold ) (8) A matrix of the form U' D U, where U is orthogonal and D has evenly spaced entries 1, ..., ULP with random signs on the diagonal. (9) A matrix of the form U' D U, where U is orthogonal and D has geometrically spaced entries 1, ..., ULP with random signs on the diagonal. (10) A matrix of the form U' D U, where U is orthogonal and D has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal. (11) Same as (8), but multiplied by SQRT( overflow threshold ) (12) Same as (8), but multiplied by SQRT( underflow threshold ) (13) Symmetric matrix with random entries chosen from (1,1). (14) Same as (13), but multiplied by SQRT( overflow threshold ) (15) Same as (13), but multiplied by SQRT( underflow threshold )
Parameters:

NSIZES
NSIZES is INTEGER The number of sizes of matrices to use. If it is zero, DCHKSB does nothing. It must be at least zero.
NNNN is INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. The values must be at least zero.
NWDTHSNWDTHS is INTEGER The number of bandwidths to use. If it is zero, DCHKSB does nothing. It must be at least zero.
KKKK is INTEGER array, dimension (NWDTHS) An array containing the bandwidths to be used for the band matrices. The values must be at least zero.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DCHKSB does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DCHKSB to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.)
AA is DOUBLE PRECISION array, dimension (LDA, max(NN)) Used to hold the matrix whose eigenvalues are to be computed.
LDALDA is INTEGER The leading dimension of A. It must be at least 2 (not 1!) and at least max( KK )+1.
SDSD is DOUBLE PRECISION array, dimension (max(NN)) Used to hold the diagonal of the tridiagonal matrix computed by DSBTRD.
SESE is DOUBLE PRECISION array, dimension (max(NN)) Used to hold the offdiagonal of the tridiagonal matrix computed by DSBTRD.
UU is DOUBLE PRECISION array, dimension (LDU, max(NN)) Used to hold the orthogonal matrix computed by DSBTRD.
LDULDU is INTEGER The leading dimension of U. It must be at least 1 and at least max( NN ).
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The number of entries in WORK. This must be at least max( LDA+1, max(NN)+1 )*max(NN).
RESULTRESULT is DOUBLE PRECISION array, dimension (4) The values computed by the tests described above. The values are currently limited to 1/ulp, to avoid overflow.
INFOINFO is INTEGER If 0, then everything ran OK.  Some Local Variables and Parameters:      ZERO, ONE Real 0 and 1. MAXTYP The number of types defined. NTEST The number of tests performed, or which can be performed so far, for the current matrix. NTESTT The total number of tests performed so far. NMAX Largest value in NN. NMATS The number of matrices generated so far. NERRS The number of tests which have exceeded THRESH so far. COND, IMODE Values to be passed to the matrix generators. ANORM Norm of A; passed to matrix generators. OVFL, UNFL Overflow and underflow thresholds. ULP, ULPINV Finest relative precision and its inverse. RTOVFL, RTUNFL Square roots of the previous 2 values. The following four arrays decode JTYPE: KTYPE(j) The general type (110) for type "j". KMODE(j) The MODE value to be passed to the matrix generator for type "j". KMAGN(j) The order of magnitude ( O(1), O(overflow^(1/2) ), O(underflow^(1/2) )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dchkst (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) AP, double precision, dimension( * ) SD, double precision, dimension( * ) SE, double precision, dimension( * ) D1, double precision, dimension( * ) D2, double precision, dimension( * ) D3, double precision, dimension( * ) D4, double precision, dimension( * ) D5, double precision, dimension( * ) WA1, double precision, dimension( * ) WA2, double precision, dimension( * ) WA3, double precision, dimension( * ) WR, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldu, * ) V, double precision, dimension( * ) VP, double precision, dimension( * ) TAU, double precision, dimension( ldu, * ) Z, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, double precision, dimension( * ) RESULT, integer INFO)
DCHKST
Purpose:

DCHKST checks the symmetric eigenvalue problem routines. DSYTRD factors A as U S U' , where ' means transpose, S is symmetric tridiagonal, and U is orthogonal. DSYTRD can use either just the lower or just the upper triangle of A; DCHKST checks both cases. U is represented as a product of Householder transformations, whose vectors are stored in the first n1 columns of V, and whose scale factors are in TAU. DSPTRD does the same as DSYTRD, except that A and V are stored in "packed" format. DORGTR constructs the matrix U from the contents of V and TAU. DOPGTR constructs the matrix U from the contents of VP and TAU. DSTEQR factors S as Z D1 Z' , where Z is the orthogonal matrix of eigenvectors and D1 is a diagonal matrix with the eigenvalues on the diagonal. D2 is the matrix of eigenvalues computed when Z is not computed. DSTERF computes D3, the matrix of eigenvalues, by the PWK method, which does not yield eigenvectors. DPTEQR factors S as Z4 D4 Z4' , for a symmetric positive definite tridiagonal matrix. D5 is the matrix of eigenvalues computed when Z is not computed. DSTEBZ computes selected eigenvalues. WA1, WA2, and WA3 will denote eigenvalues computed to high absolute accuracy, with different range options. WR will denote eigenvalues computed to high relative accuracy. DSTEIN computes Y, the eigenvectors of S, given the eigenvalues. DSTEDC factors S as Z D1 Z' , where Z is the orthogonal matrix of eigenvectors and D1 is a diagonal matrix with the eigenvalues on the diagonal ('I' option). It may also update an input orthogonal matrix, usually the output from DSYTRD/DORGTR or DSPTRD/DOPGTR ('V' option). It may also just compute eigenvalues ('N' option). DSTEMR factors S as Z D1 Z' , where Z is the orthogonal matrix of eigenvectors and D1 is a diagonal matrix with the eigenvalues on the diagonal ('I' option). DSTEMR uses the Relatively Robust Representation whenever possible. When DCHKST is called, a number of matrix "sizes" ("n's") and a number of matrix "types" are specified. For each size ("n") and each type of matrix, one matrix will be generated and used to test the symmetric eigenroutines. For each matrix, a number of tests will be performed: (1)  A  V S V'  / ( A n ulp ) DSYTRD( UPLO='U', ... ) (2)  I  UV'  / ( n ulp ) DORGTR( UPLO='U', ... ) (3)  A  V S V'  / ( A n ulp ) DSYTRD( UPLO='L', ... ) (4)  I  UV'  / ( n ulp ) DORGTR( UPLO='L', ... ) (58) Same as 14, but for DSPTRD and DOPGTR. (9)  S  Z D Z'  / ( S n ulp ) DSTEQR('V',...) (10)  I  ZZ'  / ( n ulp ) DSTEQR('V',...) (11)  D1  D2  / ( D1 ulp ) DSTEQR('N',...) (12)  D1  D3  / ( D1 ulp ) DSTERF (13) 0 if the true eigenvalues (computed by sturm count) of S are within THRESH of those in D1. 2*THRESH if they are not. (Tested using DSTECH) For S positive definite, (14)  S  Z4 D4 Z4'  / ( S n ulp ) DPTEQR('V',...) (15)  I  Z4 Z4'  / ( n ulp ) DPTEQR('V',...) (16)  D4  D5  / ( 100 D4 ulp ) DPTEQR('N',...) When S is also diagonally dominant by the factor gamma < 1, (17) max  D4(i)  WR(i)  / ( D4(i) omega ) , i omega = 2 (2n1) ULP (1 + 8 gamma**2) / (1  gamma)**4 DSTEBZ( 'A', 'E', ...) (18)  WA1  D3  / ( D3 ulp ) DSTEBZ( 'A', 'E', ...) (19) ( max { min  WA2(i)WA3(j)  } + i j max { min  WA3(i)WA2(j)  } ) / ( D3 ulp ) i j DSTEBZ( 'I', 'E', ...) (20)  S  Y WA1 Y'  / ( S n ulp ) DSTEBZ, SSTEIN (21)  I  Y Y'  / ( n ulp ) DSTEBZ, SSTEIN (22)  S  Z D Z'  / ( S n ulp ) DSTEDC('I') (23)  I  ZZ'  / ( n ulp ) DSTEDC('I') (24)  S  Z D Z'  / ( S n ulp ) DSTEDC('V') (25)  I  ZZ'  / ( n ulp ) DSTEDC('V') (26)  D1  D2  / ( D1 ulp ) DSTEDC('V') and DSTEDC('N') Test 27 is disabled at the moment because DSTEMR does not guarantee high relatvie accuracy. (27) max  D6(i)  WR(i)  / ( D6(i) omega ) , i omega = 2 (2n1) ULP (1 + 8 gamma**2) / (1  gamma)**4 DSTEMR('V', 'A') (28) max  D6(i)  WR(i)  / ( D6(i) omega ) , i omega = 2 (2n1) ULP (1 + 8 gamma**2) / (1  gamma)**4 DSTEMR('V', 'I') Tests 29 through 34 are disable at present because DSTEMR does not handle partial specturm requests. (29)  S  Z D Z'  / ( S n ulp ) DSTEMR('V', 'I') (30)  I  ZZ'  / ( n ulp ) DSTEMR('V', 'I') (31) ( max { min  WA2(i)WA3(j)  } + i j max { min  WA3(i)WA2(j)  } ) / ( D3 ulp ) i j DSTEMR('N', 'I') vs. SSTEMR('V', 'I') (32)  S  Z D Z'  / ( S n ulp ) DSTEMR('V', 'V') (33)  I  ZZ'  / ( n ulp ) DSTEMR('V', 'V') (34) ( max { min  WA2(i)WA3(j)  } + i j max { min  WA3(i)WA2(j)  } ) / ( D3 ulp ) i j DSTEMR('N', 'V') vs. SSTEMR('V', 'V') (35)  S  Z D Z'  / ( S n ulp ) DSTEMR('V', 'A') (36)  I  ZZ'  / ( n ulp ) DSTEMR('V', 'A') (37) ( max { min  WA2(i)WA3(j)  } + i j max { min  WA3(i)WA2(j)  } ) / ( D3 ulp ) i j DSTEMR('N', 'A') vs. SSTEMR('V', 'A') The "sizes" are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) The zero matrix. (2) The identity matrix. (3) A diagonal matrix with evenly spaced entries 1, ..., ULP and random signs. (ULP = (first number larger than 1)  1 ) (4) A diagonal matrix with geometrically spaced entries 1, ..., ULP and random signs. (5) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP and random signs. (6) Same as (4), but multiplied by SQRT( overflow threshold ) (7) Same as (4), but multiplied by SQRT( underflow threshold ) (8) A matrix of the form U' D U, where U is orthogonal and D has evenly spaced entries 1, ..., ULP with random signs on the diagonal. (9) A matrix of the form U' D U, where U is orthogonal and D has geometrically spaced entries 1, ..., ULP with random signs on the diagonal. (10) A matrix of the form U' D U, where U is orthogonal and D has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal. (11) Same as (8), but multiplied by SQRT( overflow threshold ) (12) Same as (8), but multiplied by SQRT( underflow threshold ) (13) Symmetric matrix with random entries chosen from (1,1). (14) Same as (13), but multiplied by SQRT( overflow threshold ) (15) Same as (13), but multiplied by SQRT( underflow threshold ) (16) Same as (8), but diagonal elements are all positive. (17) Same as (9), but diagonal elements are all positive. (18) Same as (10), but diagonal elements are all positive. (19) Same as (16), but multiplied by SQRT( overflow threshold ) (20) Same as (16), but multiplied by SQRT( underflow threshold ) (21) A diagonally dominant tridiagonal matrix with geometrically spaced diagonal entries 1, ..., ULP.
Parameters:

NSIZES
NSIZES is INTEGER The number of sizes of matrices to use. If it is zero, DCHKST does nothing. It must be at least zero.
NNNN is INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. The values must be at least zero.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DCHKST does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DCHKST to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.)
AA is DOUBLE PRECISION array of dimension ( LDA , max(NN) ) Used to hold the matrix whose eigenvalues are to be computed. On exit, A contains the last matrix actually used.
LDALDA is INTEGER The leading dimension of A. It must be at least 1 and at least max( NN ).
APAP is DOUBLE PRECISION array of dimension( max(NN)*max(NN+1)/2 ) The matrix A stored in packed format.
SDSD is DOUBLE PRECISION array of dimension( max(NN) ) The diagonal of the tridiagonal matrix computed by DSYTRD. On exit, SD and SE contain the tridiagonal form of the matrix in A.
SESE is DOUBLE PRECISION array of dimension( max(NN) ) The offdiagonal of the tridiagonal matrix computed by DSYTRD. On exit, SD and SE contain the tridiagonal form of the matrix in A.
D1D1 is DOUBLE PRECISION array of dimension( max(NN) ) The eigenvalues of A, as computed by DSTEQR simlutaneously with Z. On exit, the eigenvalues in D1 correspond with the matrix in A.
D2D2 is DOUBLE PRECISION array of dimension( max(NN) ) The eigenvalues of A, as computed by DSTEQR if Z is not computed. On exit, the eigenvalues in D2 correspond with the matrix in A.
D3D3 is DOUBLE PRECISION array of dimension( max(NN) ) The eigenvalues of A, as computed by DSTERF. On exit, the eigenvalues in D3 correspond with the matrix in A.
D4D4 is DOUBLE PRECISION array of dimension( max(NN) ) The eigenvalues of A, as computed by DPTEQR(V). DPTEQR factors S as Z4 D4 Z4* On exit, the eigenvalues in D4 correspond with the matrix in A.
D5D5 is DOUBLE PRECISION array of dimension( max(NN) ) The eigenvalues of A, as computed by DPTEQR(N) when Z is not computed. On exit, the eigenvalues in D4 correspond with the matrix in A.
WA1WA1 is DOUBLE PRECISION array of dimension( max(NN) ) All eigenvalues of A, computed to high absolute accuracy, with different range options. as computed by DSTEBZ.
WA2WA2 is DOUBLE PRECISION array of dimension( max(NN) ) Selected eigenvalues of A, computed to high absolute accuracy, with different range options. as computed by DSTEBZ. Choose random values for IL and IU, and ask for the ILth through IUth eigenvalues.
WA3WA3 is DOUBLE PRECISION array of dimension( max(NN) ) Selected eigenvalues of A, computed to high absolute accuracy, with different range options. as computed by DSTEBZ. Determine the values VL and VU of the ILth and IUth eigenvalues and ask for all eigenvalues in this range.
WRWR is DOUBLE PRECISION array of dimension( max(NN) ) All eigenvalues of A, computed to high absolute accuracy, with different options. as computed by DSTEBZ.
UU is DOUBLE PRECISION array of dimension( LDU, max(NN) ). The orthogonal matrix computed by DSYTRD + DORGTR.
LDULDU is INTEGER The leading dimension of U, Z, and V. It must be at least 1 and at least max( NN ).
VV is DOUBLE PRECISION array of dimension( LDU, max(NN) ). The Housholder vectors computed by DSYTRD in reducing A to tridiagonal form. The vectors computed with UPLO='U' are in the upper triangle, and the vectors computed with UPLO='L' are in the lower triangle. (As described in DSYTRD, the sub and superdiagonal are not set to 1, although the true Householder vector has a 1 in that position. The routines that use V, such as DORGTR, set those entries to 1 before using them, and then restore them later.)
VPVP is DOUBLE PRECISION array of dimension( max(NN)*max(NN+1)/2 ) The matrix V stored in packed format.
TAUTAU is DOUBLE PRECISION array of dimension( max(NN) ) The Householder factors computed by DSYTRD in reducing A to tridiagonal form.
ZZ is DOUBLE PRECISION array of dimension( LDU, max(NN) ). The orthogonal matrix of eigenvectors computed by DSTEQR, DPTEQR, and DSTEIN.
WORKWORK is DOUBLE PRECISION array of dimension( LWORK )
LWORKLWORK is INTEGER The number of entries in WORK. This must be at least 1 + 4 * Nmax + 2 * Nmax * lg Nmax + 3 * Nmax**2 where Nmax = max( NN(j), 2 ) and lg = log base 2.
IWORKIWORK is INTEGER array, Workspace.
LIWORKLIWORK is INTEGER The number of entries in IWORK. This must be at least 6 + 6*Nmax + 5 * Nmax * lg Nmax where Nmax = max( NN(j), 2 ) and lg = log base 2.
RESULTRESULT is DOUBLE PRECISION array, dimension (26) The values computed by the tests described above. The values are currently limited to 1/ulp, to avoid overflow.
INFOINFO is INTEGER If 0, then everything ran OK. 1: NSIZES < 0 2: Some NN(j) < 0 3: NTYPES < 0 5: THRESH < 0 9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ). 23: LDU < 1 or LDU < NMAX. 29: LWORK too small. If DLATMR, SLATMS, DSYTRD, DORGTR, DSTEQR, SSTERF, or DORMC2 returns an error code, the absolute value of it is returned.  Some Local Variables and Parameters:      ZERO, ONE Real 0 and 1. MAXTYP The number of types defined. NTEST The number of tests performed, or which can be performed so far, for the current matrix. NTESTT The total number of tests performed so far. NBLOCK Blocksize as returned by ENVIR. NMAX Largest value in NN. NMATS The number of matrices generated so far. NERRS The number of tests which have exceeded THRESH so far. COND, IMODE Values to be passed to the matrix generators. ANORM Norm of A; passed to matrix generators. OVFL, UNFL Overflow and underflow thresholds. ULP, ULPINV Finest relative precision and its inverse. RTOVFL, RTUNFL Square roots of the previous 2 values. The following four arrays decode JTYPE: KTYPE(j) The general type (110) for type "j". KMODE(j) The MODE value to be passed to the matrix generator for type "j". KMAGN(j) The order of magnitude ( O(1), O(overflow^(1/2) ), O(underflow^(1/2) )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dckcsd (integer NM, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL, integer, dimension( * ) QVAL, integer NMATS, integer, dimension( 4 ) ISEED, double precision THRESH, integer MMAX, double precision, dimension( * ) X, double precision, dimension( * ) XF, double precision, dimension( * ) U1, double precision, dimension( * ) U2, double precision, dimension( * ) V1T, double precision, dimension( * ) V2T, double precision, dimension( * ) THETA, integer, dimension( * ) IWORK, double precision, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)
DCKCSD
Purpose:

DCKCSD tests DORCSD: the CSD for an MbyM orthogonal matrix X partitioned as [ X11 X12; X21 X22 ]. X11 is PbyQ.
Parameters:

NM
NM is INTEGER The number of values of M contained in the vector MVAL.
MVALMVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
PVALPVAL is INTEGER array, dimension (NM) The values of the matrix row dimension P.
QVALQVAL is INTEGER array, dimension (NM) The values of the matrix column dimension Q.
NMATSNMATS is INTEGER The number of matrix types to be tested for each combination of matrix dimensions. If NMATS >= NTYPES (the maximum number of matrix types), then all the different types are generated for testing. If NMATS < NTYPES, another input line is read to get the numbers of the matrix types to be used.
ISEEDISEED is INTEGER array, dimension (4) On entry, the seed of the random number generator. The array elements should be between 0 and 4095, otherwise they will be reduced mod 4096, and ISEED(4) must be odd. On exit, the next seed in the random number sequence after all the test matrices have been generated.
THRESHTHRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
MMAXMMAX is INTEGER The maximum value permitted for M, used in dimensioning the work arrays.
XX is DOUBLE PRECISION array, dimension (MMAX*MMAX)
XFXF is DOUBLE PRECISION array, dimension (MMAX*MMAX)
U1U1 is DOUBLE PRECISION array, dimension (MMAX*MMAX)
U2U2 is DOUBLE PRECISION array, dimension (MMAX*MMAX)
V1TV1T is DOUBLE PRECISION array, dimension (MMAX*MMAX)
V2TV2T is DOUBLE PRECISION array, dimension (MMAX*MMAX)
THETATHETA is DOUBLE PRECISION array, dimension (MMAX)
IWORKIWORK is INTEGER array, dimension (MMAX)
WORKWORK is DOUBLE PRECISION array
RWORKRWORK is DOUBLE PRECISION array
NINNIN is INTEGER The unit number for input.
NOUTNOUT is INTEGER The unit number for output.
INFOINFO is INTEGER = 0 : successful exit > 0 : If DLAROR returns an error code, the absolute value of it is returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dckglm (integer NN, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL, integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double precision THRESH, integer NMAX, double precision, dimension( * ) A, double precision, dimension( * ) AF, double precision, dimension( * ) B, double precision, dimension( * ) BF, double precision, dimension( * ) X, double precision, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)
DCKGLM
Purpose:

DCKGLM tests DGGGLM  subroutine for solving generalized linear model problem.
Parameters:

NN
NN is INTEGER The number of values of N, M and P contained in the vectors NVAL, MVAL and PVAL.
MVALMVAL is INTEGER array, dimension (NN) The values of the matrix column dimension M.
PVALPVAL is INTEGER array, dimension (NN) The values of the matrix column dimension P.
NVALNVAL is INTEGER array, dimension (NN) The values of the matrix row dimension N.
NMATSNMATS is INTEGER The number of matrix types to be tested for each combination of matrix dimensions. If NMATS >= NTYPES (the maximum number of matrix types), then all the different types are generated for testing. If NMATS < NTYPES, another input line is read to get the numbers of the matrix types to be used.
ISEEDISEED is INTEGER array, dimension (4) On entry, the seed of the random number generator. The array elements should be between 0 and 4095, otherwise they will be reduced mod 4096, and ISEED(4) must be odd. On exit, the next seed in the random number sequence after all the test matrices have been generated.
THRESHTHRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESID >= THRESH. To have every test ratio printed, use THRESH = 0.
NMAXNMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays.
AA is DOUBLE PRECISION array, dimension (NMAX*NMAX)
AFAF is DOUBLE PRECISION array, dimension (NMAX*NMAX)
BB is DOUBLE PRECISION array, dimension (NMAX*NMAX)
BFBF is DOUBLE PRECISION array, dimension (NMAX*NMAX)
XX is DOUBLE PRECISION array, dimension (4*NMAX)
RWORKRWORK is DOUBLE PRECISION array, dimension (NMAX)
WORKWORK is DOUBLE PRECISION array, dimension (NMAX*NMAX)
NINNIN is INTEGER The unit number for input.
NOUTNOUT is INTEGER The unit number for output.
INFOINFO is INTEGER = 0 : successful exit > 0 : If DLATMS returns an error code, the absolute value of it is returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dckgqr (integer NM, integer, dimension( * ) MVAL, integer NP, integer, dimension( * ) PVAL, integer NN, integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double precision THRESH, integer NMAX, double precision, dimension( * ) A, double precision, dimension( * ) AF, double precision, dimension( * ) AQ, double precision, dimension( * ) AR, double precision, dimension( * ) TAUA, double precision, dimension( * ) B, double precision, dimension( * ) BF, double precision, dimension( * ) BZ, double precision, dimension( * ) BT, double precision, dimension( * ) BWK, double precision, dimension( * ) TAUB, double precision, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)
DCKGQR
Purpose:

DCKGQR tests DGGQRF: GQR factorization for NbyM matrix A and NbyP matrix B, DGGRQF: GRQ factorization for MbyN matrix A and PbyN matrix B.
Parameters:

NM
NM is INTEGER The number of values of M contained in the vector MVAL.
MVALMVAL is INTEGER array, dimension (NM) The values of the matrix row(column) dimension M.
NPNP is INTEGER The number of values of P contained in the vector PVAL.
PVALPVAL is INTEGER array, dimension (NP) The values of the matrix row(column) dimension P.
NNNN is INTEGER The number of values of N contained in the vector NVAL.
NVALNVAL is INTEGER array, dimension (NN) The values of the matrix column(row) dimension N.
NMATSNMATS is INTEGER The number of matrix types to be tested for each combination of matrix dimensions. If NMATS >= NTYPES (the maximum number of matrix types), then all the different types are generated for testing. If NMATS < NTYPES, another input line is read to get the numbers of the matrix types to be used.
ISEEDISEED is INTEGER array, dimension (4) On entry, the seed of the random number generator. The array elements should be between 0 and 4095, otherwise they will be reduced mod 4096, and ISEED(4) must be odd. On exit, the next seed in the random number sequence after all the test matrices have been generated.
THRESHTHRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
NMAXNMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays.
AA is DOUBLE PRECISION array, dimension (NMAX*NMAX)
AFAF is DOUBLE PRECISION array, dimension (NMAX*NMAX)
AQAQ is DOUBLE PRECISION array, dimension (NMAX*NMAX)
ARAR is DOUBLE PRECISION array, dimension (NMAX*NMAX)
TAUATAUA is DOUBLE PRECISION array, dimension (NMAX)
BB is DOUBLE PRECISION array, dimension (NMAX*NMAX)
BFBF is DOUBLE PRECISION array, dimension (NMAX*NMAX)
BZBZ is DOUBLE PRECISION array, dimension (NMAX*NMAX)
BTBT is DOUBLE PRECISION array, dimension (NMAX*NMAX)
BWKBWK is DOUBLE PRECISION array, dimension (NMAX*NMAX)
TAUBTAUB is DOUBLE PRECISION array, dimension (NMAX)
WORKWORK is DOUBLE PRECISION array, dimension (NMAX*NMAX)
RWORKRWORK is DOUBLE PRECISION array, dimension (NMAX)
NINNIN is INTEGER The unit number for input.
NOUTNOUT is INTEGER The unit number for output.
INFOINFO is INTEGER = 0 : successful exit > 0 : If DLATMS returns an error code, the absolute value of it is returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dckgsv (integer NM, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL, integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double precision THRESH, integer NMAX, double precision, dimension( * ) A, double precision, dimension( * ) AF, double precision, dimension( * ) B, double precision, dimension( * ) BF, double precision, dimension( * ) U, double precision, dimension( * ) V, double precision, dimension( * ) Q, double precision, dimension( * ) ALPHA, double precision, dimension( * ) BETA, double precision, dimension( * ) R, integer, dimension( * ) IWORK, double precision, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)
DCKGSV
Purpose:

DCKGSV tests DGGSVD: the GSVD for MbyN matrix A and PbyN matrix B.
Parameters:

NM
NM is INTEGER The number of values of M contained in the vector MVAL.
MVALMVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
PVALPVAL is INTEGER array, dimension (NP) The values of the matrix row dimension P.
NVALNVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
NMATSNMATS is INTEGER The number of matrix types to be tested for each combination of matrix dimensions. If NMATS >= NTYPES (the maximum number of matrix types), then all the different types are generated for testing. If NMATS < NTYPES, another input line is read to get the numbers of the matrix types to be used.
ISEEDISEED is INTEGER array, dimension (4) On entry, the seed of the random number generator. The array elements should be between 0 and 4095, otherwise they will be reduced mod 4096, and ISEED(4) must be odd. On exit, the next seed in the random number sequence after all the test matrices have been generated.
THRESHTHRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
NMAXNMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays.
AA is DOUBLE PRECISION array, dimension (NMAX*NMAX)
AFAF is DOUBLE PRECISION array, dimension (NMAX*NMAX)
BB is DOUBLE PRECISION array, dimension (NMAX*NMAX)
BFBF is DOUBLE PRECISION array, dimension (NMAX*NMAX)
UU is DOUBLE PRECISION array, dimension (NMAX*NMAX)
VV is DOUBLE PRECISION array, dimension (NMAX*NMAX)
QQ is DOUBLE PRECISION array, dimension (NMAX*NMAX)
ALPHAALPHA is DOUBLE PRECISION array, dimension (NMAX)
BETABETA is DOUBLE PRECISION array, dimension (NMAX)
RR is DOUBLE PRECISION array, dimension (NMAX*NMAX)
IWORKIWORK is INTEGER array, dimension (NMAX)
WORKWORK is DOUBLE PRECISION array, dimension (NMAX*NMAX)
RWORKRWORK is DOUBLE PRECISION array, dimension (NMAX)
NINNIN is INTEGER The unit number for input.
NOUTNOUT is INTEGER The unit number for output.
INFOINFO is INTEGER = 0 : successful exit > 0 : If DLATMS returns an error code, the absolute value of it is returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2015
subroutine dcklse (integer NN, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL, integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double precision THRESH, integer NMAX, double precision, dimension( * ) A, double precision, dimension( * ) AF, double precision, dimension( * ) B, double precision, dimension( * ) BF, double precision, dimension( * ) X, double precision, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)
DCKLSE
Purpose:

DCKLSE tests DGGLSE  a subroutine for solving linear equality constrained least square problem (LSE).
Parameters:

NN
NN is INTEGER The number of values of (M,P,N) contained in the vectors (MVAL, PVAL, NVAL).
MVALMVAL is INTEGER array, dimension (NN) The values of the matrix row(column) dimension M.
PVALPVAL is INTEGER array, dimension (NN) The values of the matrix row(column) dimension P.
NVALNVAL is INTEGER array, dimension (NN) The values of the matrix column(row) dimension N.
NMATSNMATS is INTEGER The number of matrix types to be tested for each combination of matrix dimensions. If NMATS >= NTYPES (the maximum number of matrix types), then all the different types are generated for testing. If NMATS < NTYPES, another input line is read to get the numbers of the matrix types to be used.
ISEEDISEED is INTEGER array, dimension (4) On entry, the seed of the random number generator. The array elements should be between 0 and 4095, otherwise they will be reduced mod 4096, and ISEED(4) must be odd. On exit, the next seed in the random number sequence after all the test matrices have been generated.
THRESHTHRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
NMAXNMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays.
AA is DOUBLE PRECISION array, dimension (NMAX*NMAX)
AFAF is DOUBLE PRECISION array, dimension (NMAX*NMAX)
BB is DOUBLE PRECISION array, dimension (NMAX*NMAX)
BFBF is DOUBLE PRECISION array, dimension (NMAX*NMAX)
XX is DOUBLE PRECISION array, dimension (5*NMAX)
WORKWORK is DOUBLE PRECISION array, dimension (NMAX*NMAX)
RWORKRWORK is DOUBLE PRECISION array, dimension (NMAX)
NINNIN is INTEGER The unit number for input.
NOUTNOUT is INTEGER The unit number for output.
INFOINFO is INTEGER = 0 : successful exit > 0 : If DLATMS returns an error code, the absolute value of it is returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dcsdts (integer M, integer P, integer Q, double precision, dimension( ldx, * ) X, double precision, dimension( ldx, * ) XF, integer LDX, double precision, dimension( ldu1, * ) U1, integer LDU1, double precision, dimension( ldu2, * ) U2, integer LDU2, double precision, dimension( ldv1t, * ) V1T, integer LDV1T, double precision, dimension( ldv2t, * ) V2T, integer LDV2T, double precision, dimension( * ) THETA, integer, dimension( * ) IWORK, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 15 ) RESULT)
DCSDTS
Purpose:

DCSDTS tests DORCSD, which, given an MbyM partitioned orthogonal matrix X, Q MQ X = [ X11 X12 ] P , [ X21 X22 ] MP computes the CSD [ U1 ]**T * [ X11 X12 ] * [ V1 ] [ U2 ] [ X21 X22 ] [ V2 ] [ I 0 0  0 0 0 ] [ 0 C 0  0 S 0 ] [ 0 0 0  0 0 I ] = [] = [ D11 D12 ] , [ 0 0 0  I 0 0 ] [ D21 D22 ] [ 0 S 0  0 C 0 ] [ 0 0 I  0 0 0 ] and also DORCSD2BY1, which, given Q [ X11 ] P , [ X21 ] MP computes the 2by1 CSD [ I 0 0 ] [ 0 C 0 ] [ 0 0 0 ] [ U1 ]**T * [ X11 ] * V1 = [] = [ D11 ] , [ U2 ] [ X21 ] [ 0 0 0 ] [ D21 ] [ 0 S 0 ] [ 0 0 I ]
Parameters:

M
M is INTEGER The number of rows of the matrix X. M >= 0.
PP is INTEGER The number of rows of the matrix X11. P >= 0.
QQ is INTEGER The number of columns of the matrix X11. Q >= 0.
XX is DOUBLE PRECISION array, dimension (LDX,M) The MbyM matrix X.
XFXF is DOUBLE PRECISION array, dimension (LDX,M) Details of the CSD of X, as returned by DORCSD; see DORCSD for further details.
LDXLDX is INTEGER The leading dimension of the arrays X and XF. LDX >= max( 1,M ).
U1U1 is DOUBLE PRECISION array, dimension(LDU1,P) The PbyP orthogonal matrix U1.
LDU1LDU1 is INTEGER The leading dimension of the array U1. LDU >= max(1,P).
U2U2 is DOUBLE PRECISION array, dimension(LDU2,MP) The (MP)by(MP) orthogonal matrix U2.
LDU2LDU2 is INTEGER The leading dimension of the array U2. LDU >= max(1,MP).
V1TV1T is DOUBLE PRECISION array, dimension(LDV1T,Q) The QbyQ orthogonal matrix V1T.
LDV1TLDV1T is INTEGER The leading dimension of the array V1T. LDV1T >= max(1,Q).
V2TV2T is DOUBLE PRECISION array, dimension(LDV2T,MQ) The (MQ)by(MQ) orthogonal matrix V2T.
LDV2TLDV2T is INTEGER The leading dimension of the array V2T. LDV2T >= max(1,MQ).
THETATHETA is DOUBLE PRECISION array, dimension MIN(P,MP,Q,MQ) The CS values of X; the essentially diagonal matrices C and S are constructed from THETA; see subroutine DORCSD for details.
IWORKIWORK is INTEGER array, dimension (M)
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The dimension of the array WORK
RWORKRWORK is DOUBLE PRECISION array
RESULTRESULT is DOUBLE PRECISION array, dimension (15) The test ratios: First, the 2by2 CSD: RESULT(1) = norm( U1'*X11*V1  D11 ) / ( MAX(1,P,Q)*EPS2 ) RESULT(2) = norm( U1'*X12*V2  D12 ) / ( MAX(1,P,MQ)*EPS2 ) RESULT(3) = norm( U2'*X21*V1  D21 ) / ( MAX(1,MP,Q)*EPS2 ) RESULT(4) = norm( U2'*X22*V2  D22 ) / ( MAX(1,MP,MQ)*EPS2 ) RESULT(5) = norm( I  U1'*U1 ) / ( MAX(1,P)*ULP ) RESULT(6) = norm( I  U2'*U2 ) / ( MAX(1,MP)*ULP ) RESULT(7) = norm( I  V1T'*V1T ) / ( MAX(1,Q)*ULP ) RESULT(8) = norm( I  V2T'*V2T ) / ( MAX(1,MQ)*ULP ) RESULT(9) = 0 if THETA is in increasing order and all angles are in [0,pi/2]; = ULPINV otherwise. Then, the 2by1 CSD: RESULT(10) = norm( U1'*X11*V1  D11 ) / ( MAX(1,P,Q)*EPS2 ) RESULT(11) = norm( U2'*X21*V1  D21 ) / ( MAX(1,MP,Q)*EPS2 ) RESULT(12) = norm( I  U1'*U1 ) / ( MAX(1,P)*ULP ) RESULT(13) = norm( I  U2'*U2 ) / ( MAX(1,MP)*ULP ) RESULT(14) = norm( I  V1T'*V1T ) / ( MAX(1,Q)*ULP ) RESULT(15) = 0 if THETA is in increasing order and all angles are in [0,pi/2]; = ULPINV otherwise. ( EPS2 = MAX( norm( I  X'*X ) / M, ULP ). )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine ddrges (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) S, double precision, dimension( lda, * ) T, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldq, * ) Z, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( 13 ) RESULT, logical, dimension( * ) BWORK, integer INFO)
DDRGES
Purpose:

DDRGES checks the nonsymmetric generalized eigenvalue (Schur form) problem driver DGGES. DGGES factors A and B as Q S Z' and Q T Z' , where ' means transpose, T is upper triangular, S is in generalized Schur form (block upper triangular, with 1x1 and 2x2 blocks on the diagonal, the 2x2 blocks corresponding to complex conjugate pairs of generalized eigenvalues), and Q and Z are orthogonal. It also computes the generalized eigenvalues (alpha(j),beta(j)), j=1,...,n, Thus, w(j) = alpha(j)/beta(j) is a root of the characteristic equation det( A  w(j) B ) = 0 Optionally it also reorder the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal block of the Schur forms. When DDRGES is called, a number of matrix "sizes" ("N's") and a number of matrix "TYPES" are specified. For each size ("N") and each TYPE of matrix, a pair of matrices (A, B) will be generated and used for testing. For each matrix pair, the following 13 tests will be performed and compared with the threshold THRESH except the tests (5), (11) and (13). (1)  A  Q S Z'  / ( A n ulp ) (no sorting of eigenvalues) (2)  B  Q T Z'  / ( B n ulp ) (no sorting of eigenvalues) (3)  I  QQ'  / ( n ulp ) (no sorting of eigenvalues) (4)  I  ZZ'  / ( n ulp ) (no sorting of eigenvalues) (5) if A is in Schur form (i.e. quasitriangular form) (no sorting of eigenvalues) (6) if eigenvalues = diagonal blocks of the Schur form (S, T), i.e., test the maximum over j of D(j) where: if alpha(j) is real: alpha(j)  S(j,j) beta(j)  T(j,j) D(j) =  +  max(alpha(j),S(j,j)) max(beta(j),T(j,j)) if alpha(j) is complex:  det( s S  w T )  D(j) =  ulp max( s norm(S), w norm(T) )*norm( s S  w T ) and S and T are here the 2 x 2 diagonal blocks of S and T corresponding to the jth and j+1th eigenvalues. (no sorting of eigenvalues) (7)  (A,B)  Q (S,T) Z'  / (  (A,B)  n ulp ) (with sorting of eigenvalues). (8)  I  QQ'  / ( n ulp ) (with sorting of eigenvalues). (9)  I  ZZ'  / ( n ulp ) (with sorting of eigenvalues). (10) if A is in Schur form (i.e. quasitriangular form) (with sorting of eigenvalues). (11) if eigenvalues = diagonal blocks of the Schur form (S, T), i.e. test the maximum over j of D(j) where: if alpha(j) is real: alpha(j)  S(j,j) beta(j)  T(j,j) D(j) =  +  max(alpha(j),S(j,j)) max(beta(j),T(j,j)) if alpha(j) is complex:  det( s S  w T )  D(j) =  ulp max( s norm(S), w norm(T) )*norm( s S  w T ) and S and T are here the 2 x 2 diagonal blocks of S and T corresponding to the jth and j+1th eigenvalues. (with sorting of eigenvalues). (12) if sorting worked and SDIM is the number of eigenvalues which were SELECTed. Test Matrices ============= The sizes of the test matrices are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) ( 0, 0 ) (a pair of zero matrices) (2) ( I, 0 ) (an identity and a zero matrix) (3) ( 0, I ) (an identity and a zero matrix) (4) ( I, I ) (a pair of identity matrices) t t (5) ( J , J ) (a pair of transposed Jordan blocks) t ( I 0 ) (6) ( X, Y ) where X = ( J 0 ) and Y = ( t ) ( 0 I ) ( 0 J ) and I is a k x k identity and J a (k+1)x(k+1) Jordan block; k=(N1)/2 (7) ( D, I ) where D is diag( 0, 1,..., N1 ) (a diagonal matrix with those diagonal entries.) (8) ( I, D ) (9) ( big*D, small*I ) where "big" is near overflow and small=1/big (10) ( small*D, big*I ) (11) ( big*I, small*D ) (12) ( small*I, big*D ) (13) ( big*D, big*I ) (14) ( small*D, small*I ) (15) ( D1, D2 ) where D1 is diag( 0, 0, 1, ..., N3, 0 ) and D2 is diag( 0, N3, N4,..., 1, 0, 0 ) t t (16) Q ( J , J ) Z where Q and Z are random orthogonal matrices. (17) Q ( T1, T2 ) Z where T1 and T2 are upper triangular matrices with random O(1) entries above the diagonal and diagonal entries diag(T1) = ( 0, 0, 1, ..., N3, 0 ) and diag(T2) = ( 0, N3, N4,..., 1, 0, 0 ) (18) Q ( T1, T2 ) Z diag(T1) = ( 0, 0, 1, 1, s, ..., s, 0 ) diag(T2) = ( 0, 1, 0, 1,..., 1, 0 ) s = machine precision. (19) Q ( T1, T2 ) Z diag(T1)=( 0,0,1,1, 1d, ..., 1(N5)*d=s, 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 ) N5 (20) Q ( T1, T2 ) Z diag(T1)=( 0, 0, 1, 1, a, ..., a =s, 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 ) (21) Q ( T1, T2 ) Z diag(T1)=( 0, 0, 1, r1, r2, ..., r(N4), 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 ) where r1,..., r(N4) are random. (22) Q ( big*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (23) Q ( small*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (24) Q ( small*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (25) Q ( big*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (26) Q ( T1, T2 ) Z where T1 and T2 are random uppertriangular matrices.
Parameters:

NSIZES
NSIZES is INTEGER The number of sizes of matrices to use. If it is zero, DDRGES does nothing. NSIZES >= 0.
NNNN is INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. NN >= 0.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DDRGES does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A on input. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DDRGES to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. THRESH >= 0.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.)
AA is DOUBLE PRECISION array, dimension(LDA, max(NN)) Used to hold the original A matrix. Used as input only if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and DOTYPE(MAXTYP+1)=.TRUE.
LDALDA is INTEGER The leading dimension of A, B, S, and T. It must be at least 1 and at least max( NN ).
BB is DOUBLE PRECISION array, dimension(LDA, max(NN)) Used to hold the original B matrix. Used as input only if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and DOTYPE(MAXTYP+1)=.TRUE.
SS is DOUBLE PRECISION array, dimension (LDA, max(NN)) The Schur form matrix computed from A by DGGES. On exit, S contains the Schur form matrix corresponding to the matrix in A.
TT is DOUBLE PRECISION array, dimension (LDA, max(NN)) The upper triangular matrix computed from B by DGGES.
QQ is DOUBLE PRECISION array, dimension (LDQ, max(NN)) The (left) orthogonal matrix computed by DGGES.
LDQLDQ is INTEGER The leading dimension of Q and Z. It must be at least 1 and at least max( NN ).
ZZ is DOUBLE PRECISION array, dimension( LDQ, max(NN) ) The (right) orthogonal matrix computed by DGGES.
ALPHARALPHAR is DOUBLE PRECISION array, dimension (max(NN))
ALPHAIALPHAI is DOUBLE PRECISION array, dimension (max(NN))
BETABETA is DOUBLE PRECISION array, dimension (max(NN)) The generalized eigenvalues of (A,B) computed by DGGES. ( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the kth generalized eigenvalue of A and B.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The dimension of the array WORK. LWORK >= MAX( 10*(N+1), 3*N*N ), where N is the largest matrix dimension.
RESULTRESULT is DOUBLE PRECISION array, dimension (15) The values computed by the tests described above. The values are currently limited to 1/ulp, to avoid overflow.
BWORKBWORK is LOGICAL array, dimension (N)
INFOINFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value. > 0: A routine returned an error code. INFO is the absolute value of the INFO value returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine ddrges3 (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) S, double precision, dimension( lda, * ) T, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldq, * ) Z, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( 13 ) RESULT, logical, dimension( * ) BWORK, integer INFO)
DDRGES3
Purpose:

DDRGES3 checks the nonsymmetric generalized eigenvalue (Schur form) problem driver DGGES3. DGGES3 factors A and B as Q S Z' and Q T Z' , where ' means transpose, T is upper triangular, S is in generalized Schur form (block upper triangular, with 1x1 and 2x2 blocks on the diagonal, the 2x2 blocks corresponding to complex conjugate pairs of generalized eigenvalues), and Q and Z are orthogonal. It also computes the generalized eigenvalues (alpha(j),beta(j)), j=1,...,n, Thus, w(j) = alpha(j)/beta(j) is a root of the characteristic equation det( A  w(j) B ) = 0 Optionally it also reorder the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal block of the Schur forms. When DDRGES3 is called, a number of matrix "sizes" ("N's") and a number of matrix "TYPES" are specified. For each size ("N") and each TYPE of matrix, a pair of matrices (A, B) will be generated and used for testing. For each matrix pair, the following 13 tests will be performed and compared with the threshold THRESH except the tests (5), (11) and (13). (1)  A  Q S Z'  / ( A n ulp ) (no sorting of eigenvalues) (2)  B  Q T Z'  / ( B n ulp ) (no sorting of eigenvalues) (3)  I  QQ'  / ( n ulp ) (no sorting of eigenvalues) (4)  I  ZZ'  / ( n ulp ) (no sorting of eigenvalues) (5) if A is in Schur form (i.e. quasitriangular form) (no sorting of eigenvalues) (6) if eigenvalues = diagonal blocks of the Schur form (S, T), i.e., test the maximum over j of D(j) where: if alpha(j) is real: alpha(j)  S(j,j) beta(j)  T(j,j) D(j) =  +  max(alpha(j),S(j,j)) max(beta(j),T(j,j)) if alpha(j) is complex:  det( s S  w T )  D(j) =  ulp max( s norm(S), w norm(T) )*norm( s S  w T ) and S and T are here the 2 x 2 diagonal blocks of S and T corresponding to the jth and j+1th eigenvalues. (no sorting of eigenvalues) (7)  (A,B)  Q (S,T) Z'  / (  (A,B)  n ulp ) (with sorting of eigenvalues). (8)  I  QQ'  / ( n ulp ) (with sorting of eigenvalues). (9)  I  ZZ'  / ( n ulp ) (with sorting of eigenvalues). (10) if A is in Schur form (i.e. quasitriangular form) (with sorting of eigenvalues). (11) if eigenvalues = diagonal blocks of the Schur form (S, T), i.e. test the maximum over j of D(j) where: if alpha(j) is real: alpha(j)  S(j,j) beta(j)  T(j,j) D(j) =  +  max(alpha(j),S(j,j)) max(beta(j),T(j,j)) if alpha(j) is complex:  det( s S  w T )  D(j) =  ulp max( s norm(S), w norm(T) )*norm( s S  w T ) and S and T are here the 2 x 2 diagonal blocks of S and T corresponding to the jth and j+1th eigenvalues. (with sorting of eigenvalues). (12) if sorting worked and SDIM is the number of eigenvalues which were SELECTed. Test Matrices ============= The sizes of the test matrices are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) ( 0, 0 ) (a pair of zero matrices) (2) ( I, 0 ) (an identity and a zero matrix) (3) ( 0, I ) (an identity and a zero matrix) (4) ( I, I ) (a pair of identity matrices) t t (5) ( J , J ) (a pair of transposed Jordan blocks) t ( I 0 ) (6) ( X, Y ) where X = ( J 0 ) and Y = ( t ) ( 0 I ) ( 0 J ) and I is a k x k identity and J a (k+1)x(k+1) Jordan block; k=(N1)/2 (7) ( D, I ) where D is diag( 0, 1,..., N1 ) (a diagonal matrix with those diagonal entries.) (8) ( I, D ) (9) ( big*D, small*I ) where "big" is near overflow and small=1/big (10) ( small*D, big*I ) (11) ( big*I, small*D ) (12) ( small*I, big*D ) (13) ( big*D, big*I ) (14) ( small*D, small*I ) (15) ( D1, D2 ) where D1 is diag( 0, 0, 1, ..., N3, 0 ) and D2 is diag( 0, N3, N4,..., 1, 0, 0 ) t t (16) Q ( J , J ) Z where Q and Z are random orthogonal matrices. (17) Q ( T1, T2 ) Z where T1 and T2 are upper triangular matrices with random O(1) entries above the diagonal and diagonal entries diag(T1) = ( 0, 0, 1, ..., N3, 0 ) and diag(T2) = ( 0, N3, N4,..., 1, 0, 0 ) (18) Q ( T1, T2 ) Z diag(T1) = ( 0, 0, 1, 1, s, ..., s, 0 ) diag(T2) = ( 0, 1, 0, 1,..., 1, 0 ) s = machine precision. (19) Q ( T1, T2 ) Z diag(T1)=( 0,0,1,1, 1d, ..., 1(N5)*d=s, 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 ) N5 (20) Q ( T1, T2 ) Z diag(T1)=( 0, 0, 1, 1, a, ..., a =s, 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 ) (21) Q ( T1, T2 ) Z diag(T1)=( 0, 0, 1, r1, r2, ..., r(N4), 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 ) where r1,..., r(N4) are random. (22) Q ( big*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (23) Q ( small*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (24) Q ( small*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (25) Q ( big*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (26) Q ( T1, T2 ) Z where T1 and T2 are random uppertriangular matrices.
Parameters:

NSIZES
NSIZES is INTEGER The number of sizes of matrices to use. If it is zero, DDRGES3 does nothing. NSIZES >= 0.
NNNN is INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. NN >= 0.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DDRGES3 does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A on input. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DDRGES3 to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. THRESH >= 0.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.)
AA is DOUBLE PRECISION array, dimension(LDA, max(NN)) Used to hold the original A matrix. Used as input only if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and DOTYPE(MAXTYP+1)=.TRUE.
LDALDA is INTEGER The leading dimension of A, B, S, and T. It must be at least 1 and at least max( NN ).
BB is DOUBLE PRECISION array, dimension(LDA, max(NN)) Used to hold the original B matrix. Used as input only if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and DOTYPE(MAXTYP+1)=.TRUE.
SS is DOUBLE PRECISION array, dimension (LDA, max(NN)) The Schur form matrix computed from A by DGGES3. On exit, S contains the Schur form matrix corresponding to the matrix in A.
TT is DOUBLE PRECISION array, dimension (LDA, max(NN)) The upper triangular matrix computed from B by DGGES3.
QQ is DOUBLE PRECISION array, dimension (LDQ, max(NN)) The (left) orthogonal matrix computed by DGGES3.
LDQLDQ is INTEGER The leading dimension of Q and Z. It must be at least 1 and at least max( NN ).
ZZ is DOUBLE PRECISION array, dimension( LDQ, max(NN) ) The (right) orthogonal matrix computed by DGGES3.
ALPHARALPHAR is DOUBLE PRECISION array, dimension (max(NN))
ALPHAIALPHAI is DOUBLE PRECISION array, dimension (max(NN))
BETABETA is DOUBLE PRECISION array, dimension (max(NN)) The generalized eigenvalues of (A,B) computed by DGGES3. ( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the kth generalized eigenvalue of A and B.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The dimension of the array WORK. LWORK >= MAX( 10*(N+1), 3*N*N ), where N is the largest matrix dimension.
RESULTRESULT is DOUBLE PRECISION array, dimension (15) The values computed by the tests described above. The values are currently limited to 1/ulp, to avoid overflow.
BWORKBWORK is LOGICAL array, dimension (N)
INFOINFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value. > 0: A routine returned an error code. INFO is the absolute value of the INFO value returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 February 2015
subroutine ddrgev (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) S, double precision, dimension( lda, * ) T, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldq, * ) Z, double precision, dimension( ldqe, * ) QE, integer LDQE, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( * ) ALPHR1, double precision, dimension( * ) ALPHI1, double precision, dimension( * ) BETA1, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RESULT, integer INFO)
DDRGEV
Purpose:

DDRGEV checks the nonsymmetric generalized eigenvalue problem driver routine DGGEV. DGGEV computes for a pair of nbyn nonsymmetric matrices (A,B) the generalized eigenvalues and, optionally, the left and right eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A  w*B is singular. It is usually represented as the pair (alpha,beta), as there is reasonable interpretation for beta=0, and even for both being zero. A right generalized eigenvector corresponding to a generalized eigenvalue w for a pair of matrices (A,B) is a vector r such that (A  wB) * r = 0. A left generalized eigenvector is a vector l such that l**H * (A  wB) = 0, where l**H is the conjugatetranspose of l. When DDRGEV is called, a number of matrix "sizes" ("n's") and a number of matrix "types" are specified. For each size ("n") and each type of matrix, a pair of matrices (A, B) will be generated and used for testing. For each matrix pair, the following tests will be performed and compared with the threshold THRESH. Results from DGGEV: (1) max over all left eigenvalue/vector pairs (alpha/beta,l) of  VL**H * (beta A  alpha B) /( ulp max(beta A, alpha B) ) where VL**H is the conjugatetranspose of VL. (2)  VL(i)  1  / ulp and whether largest component real VL(i) denotes the ith column of VL. (3) max over all left eigenvalue/vector pairs (alpha/beta,r) of  (beta A  alpha B) * VR  / ( ulp max(beta A, alpha B) ) (4)  VR(i)  1  / ulp and whether largest component real VR(i) denotes the ith column of VR. (5) W(full) = W(partial) W(full) denotes the eigenvalues computed when both l and r are also computed, and W(partial) denotes the eigenvalues computed when only W, only W and r, or only W and l are computed. (6) VL(full) = VL(partial) VL(full) denotes the left eigenvectors computed when both l and r are computed, and VL(partial) denotes the result when only l is computed. (7) VR(full) = VR(partial) VR(full) denotes the right eigenvectors computed when both l and r are also computed, and VR(partial) denotes the result when only l is computed. Test Matrices   The sizes of the test matrices are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) ( 0, 0 ) (a pair of zero matrices) (2) ( I, 0 ) (an identity and a zero matrix) (3) ( 0, I ) (an identity and a zero matrix) (4) ( I, I ) (a pair of identity matrices) t t (5) ( J , J ) (a pair of transposed Jordan blocks) t ( I 0 ) (6) ( X, Y ) where X = ( J 0 ) and Y = ( t ) ( 0 I ) ( 0 J ) and I is a k x k identity and J a (k+1)x(k+1) Jordan block; k=(N1)/2 (7) ( D, I ) where D is diag( 0, 1,..., N1 ) (a diagonal matrix with those diagonal entries.) (8) ( I, D ) (9) ( big*D, small*I ) where "big" is near overflow and small=1/big (10) ( small*D, big*I ) (11) ( big*I, small*D ) (12) ( small*I, big*D ) (13) ( big*D, big*I ) (14) ( small*D, small*I ) (15) ( D1, D2 ) where D1 is diag( 0, 0, 1, ..., N3, 0 ) and D2 is diag( 0, N3, N4,..., 1, 0, 0 ) t t (16) Q ( J , J ) Z where Q and Z are random orthogonal matrices. (17) Q ( T1, T2 ) Z where T1 and T2 are upper triangular matrices with random O(1) entries above the diagonal and diagonal entries diag(T1) = ( 0, 0, 1, ..., N3, 0 ) and diag(T2) = ( 0, N3, N4,..., 1, 0, 0 ) (18) Q ( T1, T2 ) Z diag(T1) = ( 0, 0, 1, 1, s, ..., s, 0 ) diag(T2) = ( 0, 1, 0, 1,..., 1, 0 ) s = machine precision. (19) Q ( T1, T2 ) Z diag(T1)=( 0,0,1,1, 1d, ..., 1(N5)*d=s, 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 ) N5 (20) Q ( T1, T2 ) Z diag(T1)=( 0, 0, 1, 1, a, ..., a =s, 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 ) (21) Q ( T1, T2 ) Z diag(T1)=( 0, 0, 1, r1, r2, ..., r(N4), 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 ) where r1,..., r(N4) are random. (22) Q ( big*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (23) Q ( small*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (24) Q ( small*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (25) Q ( big*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (26) Q ( T1, T2 ) Z where T1 and T2 are random uppertriangular matrices.
Parameters:

NSIZES
NSIZES is INTEGER The number of sizes of matrices to use. If it is zero, DDRGES does nothing. NSIZES >= 0.
NNNN is INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. NN >= 0.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DDRGES does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DDRGES to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IERR not equal to 0.)
AA is DOUBLE PRECISION array, dimension(LDA, max(NN)) Used to hold the original A matrix. Used as input only if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and DOTYPE(MAXTYP+1)=.TRUE.
LDALDA is INTEGER The leading dimension of A, B, S, and T. It must be at least 1 and at least max( NN ).
BB is DOUBLE PRECISION array, dimension(LDA, max(NN)) Used to hold the original B matrix. Used as input only if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and DOTYPE(MAXTYP+1)=.TRUE.
SS is DOUBLE PRECISION array, dimension (LDA, max(NN)) The Schur form matrix computed from A by DGGES. On exit, S contains the Schur form matrix corresponding to the matrix in A.
TT is DOUBLE PRECISION array, dimension (LDA, max(NN)) The upper triangular matrix computed from B by DGGES.
QQ is DOUBLE PRECISION array, dimension (LDQ, max(NN)) The (left) eigenvectors matrix computed by DGGEV.
LDQLDQ is INTEGER The leading dimension of Q and Z. It must be at least 1 and at least max( NN ).
ZZ is DOUBLE PRECISION array, dimension( LDQ, max(NN) ) The (right) orthogonal matrix computed by DGGES.
QEQE is DOUBLE PRECISION array, dimension( LDQ, max(NN) ) QE holds the computed right or left eigenvectors.
LDQELDQE is INTEGER The leading dimension of QE. LDQE >= max(1,max(NN)).
ALPHARALPHAR is DOUBLE PRECISION array, dimension (max(NN))
ALPHAIALPHAI is DOUBLE PRECISION array, dimension (max(NN))
BETABETA is DOUBLE PRECISION array, dimension (max(NN)) The generalized eigenvalues of (A,B) computed by DGGEV. ( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the kth generalized eigenvalue of A and B.
ALPHR1ALPHR1 is DOUBLE PRECISION array, dimension (max(NN))
ALPHI1ALPHI1 is DOUBLE PRECISION array, dimension (max(NN))
BETA1BETA1 is DOUBLE PRECISION array, dimension (max(NN)) Like ALPHAR, ALPHAI, BETA, these arrays contain the eigenvalues of A and B, but those computed when DGGEV only computes a partial eigendecomposition, i.e. not the eigenvalues and left and right eigenvectors.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The number of entries in WORK. LWORK >= MAX( 8*N, N*(N+1) ).
RESULTRESULT is DOUBLE PRECISION array, dimension (2) The values computed by the tests described above. The values are currently limited to 1/ulp, to avoid overflow.
INFOINFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value. > 0: A routine returned an error code. INFO is the absolute value of the INFO value returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine ddrgev3 (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) S, double precision, dimension( lda, * ) T, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldq, * ) Z, double precision, dimension( ldqe, * ) QE, integer LDQE, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( * ) ALPHR1, double precision, dimension( * ) ALPHI1, double precision, dimension( * ) BETA1, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RESULT, integer INFO)
DDRGEV3
Purpose:

DDRGEV3 checks the nonsymmetric generalized eigenvalue problem driver routine DGGEV3. DGGEV3 computes for a pair of nbyn nonsymmetric matrices (A,B) the generalized eigenvalues and, optionally, the left and right eigenvectors. A generalized eigenvalue for a pair of matrices (A,B) is a scalar w or a ratio alpha/beta = w, such that A  w*B is singular. It is usually represented as the pair (alpha,beta), as there is reasonable interpretation for beta=0, and even for both being zero. A right generalized eigenvector corresponding to a generalized eigenvalue w for a pair of matrices (A,B) is a vector r such that (A  wB) * r = 0. A left generalized eigenvector is a vector l such that l**H * (A  wB) = 0, where l**H is the conjugatetranspose of l. When DDRGEV3 is called, a number of matrix "sizes" ("n's") and a number of matrix "types" are specified. For each size ("n") and each type of matrix, a pair of matrices (A, B) will be generated and used for testing. For each matrix pair, the following tests will be performed and compared with the threshold THRESH. Results from DGGEV3: (1) max over all left eigenvalue/vector pairs (alpha/beta,l) of  VL**H * (beta A  alpha B) /( ulp max(beta A, alpha B) ) where VL**H is the conjugatetranspose of VL. (2)  VL(i)  1  / ulp and whether largest component real VL(i) denotes the ith column of VL. (3) max over all left eigenvalue/vector pairs (alpha/beta,r) of  (beta A  alpha B) * VR  / ( ulp max(beta A, alpha B) ) (4)  VR(i)  1  / ulp and whether largest component real VR(i) denotes the ith column of VR. (5) W(full) = W(partial) W(full) denotes the eigenvalues computed when both l and r are also computed, and W(partial) denotes the eigenvalues computed when only W, only W and r, or only W and l are computed. (6) VL(full) = VL(partial) VL(full) denotes the left eigenvectors computed when both l and r are computed, and VL(partial) denotes the result when only l is computed. (7) VR(full) = VR(partial) VR(full) denotes the right eigenvectors computed when both l and r are also computed, and VR(partial) denotes the result when only l is computed. Test Matrices   The sizes of the test matrices are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) ( 0, 0 ) (a pair of zero matrices) (2) ( I, 0 ) (an identity and a zero matrix) (3) ( 0, I ) (an identity and a zero matrix) (4) ( I, I ) (a pair of identity matrices) t t (5) ( J , J ) (a pair of transposed Jordan blocks) t ( I 0 ) (6) ( X, Y ) where X = ( J 0 ) and Y = ( t ) ( 0 I ) ( 0 J ) and I is a k x k identity and J a (k+1)x(k+1) Jordan block; k=(N1)/2 (7) ( D, I ) where D is diag( 0, 1,..., N1 ) (a diagonal matrix with those diagonal entries.) (8) ( I, D ) (9) ( big*D, small*I ) where "big" is near overflow and small=1/big (10) ( small*D, big*I ) (11) ( big*I, small*D ) (12) ( small*I, big*D ) (13) ( big*D, big*I ) (14) ( small*D, small*I ) (15) ( D1, D2 ) where D1 is diag( 0, 0, 1, ..., N3, 0 ) and D2 is diag( 0, N3, N4,..., 1, 0, 0 ) t t (16) Q ( J , J ) Z where Q and Z are random orthogonal matrices. (17) Q ( T1, T2 ) Z where T1 and T2 are upper triangular matrices with random O(1) entries above the diagonal and diagonal entries diag(T1) = ( 0, 0, 1, ..., N3, 0 ) and diag(T2) = ( 0, N3, N4,..., 1, 0, 0 ) (18) Q ( T1, T2 ) Z diag(T1) = ( 0, 0, 1, 1, s, ..., s, 0 ) diag(T2) = ( 0, 1, 0, 1,..., 1, 0 ) s = machine precision. (19) Q ( T1, T2 ) Z diag(T1)=( 0,0,1,1, 1d, ..., 1(N5)*d=s, 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 ) N5 (20) Q ( T1, T2 ) Z diag(T1)=( 0, 0, 1, 1, a, ..., a =s, 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 ) (21) Q ( T1, T2 ) Z diag(T1)=( 0, 0, 1, r1, r2, ..., r(N4), 0 ) diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 ) where r1,..., r(N4) are random. (22) Q ( big*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (23) Q ( small*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (24) Q ( small*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (25) Q ( big*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N3, 0 ) diag(T2) = ( 0, 1, ..., 1, 0, 0 ) (26) Q ( T1, T2 ) Z where T1 and T2 are random uppertriangular matrices.
Parameters:

NSIZES
NSIZES is INTEGER The number of sizes of matrices to use. If it is zero, DDRGEV3 does nothing. NSIZES >= 0.
NNNN is INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. NN >= 0.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DDRGEV3 does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DDRGEV3 to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IERR not equal to 0.)
AA is DOUBLE PRECISION array, dimension(LDA, max(NN)) Used to hold the original A matrix. Used as input only if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and DOTYPE(MAXTYP+1)=.TRUE.
LDALDA is INTEGER The leading dimension of A, B, S, and T. It must be at least 1 and at least max( NN ).
BB is DOUBLE PRECISION array, dimension(LDA, max(NN)) Used to hold the original B matrix. Used as input only if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and DOTYPE(MAXTYP+1)=.TRUE.
SS is DOUBLE PRECISION array, dimension (LDA, max(NN)) The Schur form matrix computed from A by DGGEV3. On exit, S contains the Schur form matrix corresponding to the matrix in A.
TT is DOUBLE PRECISION array, dimension (LDA, max(NN)) The upper triangular matrix computed from B by DGGEV3.
QQ is DOUBLE PRECISION array, dimension (LDQ, max(NN)) The (left) eigenvectors matrix computed by DGGEV3.
LDQLDQ is INTEGER The leading dimension of Q and Z. It must be at least 1 and at least max( NN ).
ZZ is DOUBLE PRECISION array, dimension( LDQ, max(NN) ) The (right) orthogonal matrix computed by DGGEV3.
QEQE is DOUBLE PRECISION array, dimension( LDQ, max(NN) ) QE holds the computed right or left eigenvectors.
LDQELDQE is INTEGER The leading dimension of QE. LDQE >= max(1,max(NN)).
ALPHARALPHAR is DOUBLE PRECISION array, dimension (max(NN))
ALPHAIALPHAI is DOUBLE PRECISION array, dimension (max(NN))
BETABETA is DOUBLE PRECISION array, dimension (max(NN)) The generalized eigenvalues of (A,B) computed by DGGEV3. ( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the kth generalized eigenvalue of A and B.
ALPHR1ALPHR1 is DOUBLE PRECISION array, dimension (max(NN))
ALPHI1ALPHI1 is DOUBLE PRECISION array, dimension (max(NN))
BETA1BETA1 is DOUBLE PRECISION array, dimension (max(NN)) Like ALPHAR, ALPHAI, BETA, these arrays contain the eigenvalues of A and B, but those computed when DGGEV3 only computes a partial eigendecomposition, i.e. not the eigenvalues and left and right eigenvectors.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The number of entries in WORK. LWORK >= MAX( 8*N, N*(N+1) ).
RESULTRESULT is DOUBLE PRECISION array, dimension (2) The values computed by the tests described above. The values are currently limited to 1/ulp, to avoid overflow.
INFOINFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value. > 0: A routine returned an error code. INFO is the absolute value of the INFO value returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 February 2015
subroutine ddrgsx (integer NSIZE, integer NCMAX, double precision THRESH, integer NIN, integer NOUT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) AI, double precision, dimension( lda, * ) BI, double precision, dimension( lda, * ) Z, double precision, dimension( lda, * ) Q, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) S, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, logical, dimension( * ) BWORK, integer INFO)
DDRGSX
Purpose:

DDRGSX checks the nonsymmetric generalized eigenvalue (Schur form) problem expert driver DGGESX. DGGESX factors A and B as Q S Z' and Q T Z', where ' means transpose, T is upper triangular, S is in generalized Schur form (block upper triangular, with 1x1 and 2x2 blocks on the diagonal, the 2x2 blocks corresponding to complex conjugate pairs of generalized eigenvalues), and Q and Z are orthogonal. It also computes the generalized eigenvalues (alpha(1),beta(1)), ..., (alpha(n),beta(n)). Thus, w(j) = alpha(j)/beta(j) is a root of the characteristic equation det( A  w(j) B ) = 0 Optionally it also reorders the eigenvalues so that a selected cluster of eigenvalues appears in the leading diagonal block of the Schur forms; computes a reciprocal condition number for the average of the selected eigenvalues; and computes a reciprocal condition number for the right and left deflating subspaces corresponding to the selected eigenvalues. When DDRGSX is called with NSIZE > 0, five (5) types of builtin matrix pairs are used to test the routine DGGESX. When DDRGSX is called with NSIZE = 0, it reads in test matrix data to test DGGESX. For each matrix pair, the following tests will be performed and compared with the threshold THRESH except for the tests (7) and (9): (1)  A  Q S Z'  / ( A n ulp ) (2)  B  Q T Z'  / ( B n ulp ) (3)  I  QQ'  / ( n ulp ) (4)  I  ZZ'  / ( n ulp ) (5) if A is in Schur form (i.e. quasitriangular form) (6) maximum over j of D(j) where: if alpha(j) is real: alpha(j)  S(j,j) beta(j)  T(j,j) D(j) =  +  max(alpha(j),S(j,j)) max(beta(j),T(j,j)) if alpha(j) is complex:  det( s S  w T )  D(j) =  ulp max( s norm(S), w norm(T) )*norm( s S  w T ) and S and T are here the 2 x 2 diagonal blocks of S and T corresponding to the jth and j+1th eigenvalues. (7) if sorting worked and SDIM is the number of eigenvalues which were selected. (8) the estimated value DIF does not differ from the true values of Difu and Difl more than a factor 10*THRESH. If the estimate DIF equals zero the corresponding true values of Difu and Difl should be less than EPS*norm(A, B). If the true value of Difu and Difl equal zero, the estimate DIF should be less than EPS*norm(A, B). (9) If INFO = N+3 is returned by DGGESX, the reordering "failed" and we check that DIF = PL = PR = 0 and that the true value of Difu and Difl is < EPS*norm(A, B). We count the events when INFO=N+3. For readin test matrices, the above tests are run except that the exact value for DIF (and PL) is input data. Additionally, there is one more test run for readin test matrices: (10) the estimated value PL does not differ from the true value of PLTRU more than a factor THRESH. If the estimate PL equals zero the corresponding true value of PLTRU should be less than EPS*norm(A, B). If the true value of PLTRU equal zero, the estimate PL should be less than EPS*norm(A, B). Note that for the builtin tests, a total of 10*NSIZE*(NSIZE1) matrix pairs are generated and tested. NSIZE should be kept small. SVD (routine DGESVD) is used for computing the true value of DIF_u and DIF_l when testing the builtin test problems. Builtin Test Matrices ====================== All builtin test matrices are the 2 by 2 block of triangular matrices A = [ A11 A12 ] and B = [ B11 B12 ] [ A22 ] [ B22 ] where for different type of A11 and A22 are given as the following. A12 and B12 are chosen so that the generalized Sylvester equation A11*R  L*A22 = A12 B11*R  L*B22 = B12 have prescribed solution R and L. Type 1: A11 = J_m(1,1) and A_22 = J_k(1a,1). B11 = I_m, B22 = I_k where J_k(a,b) is the kbyk Jordan block with ``a'' on diagonal and ``b'' on superdiagonal. Type 2: A11 = (a_ij) = ( 2(.5sin(i)) ) and B11 = (b_ij) = ( 2(.5sin(ij)) ) for i=1,...,m, j=i,...,m A22 = (a_ij) = ( 2(.5sin(i+j)) ) and B22 = (b_ij) = ( 2(.5sin(ij)) ) for i=m+1,...,k, j=i,...,k Type 3: A11, A22 and B11, B22 are chosen as for Type 2, but each second diagonal block in A_11 and each third diagonal block in A_22 are made as 2 by 2 blocks. Type 4: A11 = ( 20(.5  sin(ij)) ) and B22 = ( 2(.5  sin(i+j)) ) for i=1,...,m, j=1,...,m and A22 = ( 20(.5  sin(i+j)) ) and B22 = ( 2(.5  sin(ij)) ) for i=m+1,...,k, j=m+1,...,k Type 5: (A,B) and have potentially close or common eigenvalues and very large departure from block diagonality A_11 is chosen as the m x m leading submatrix of A_1:  1 b   b 1   1+d b   b 1+d  A_1 =  d 1   1 d   d 1   1 d   1  and A_22 is chosen as the k x k leading submatrix of A_2:  1 b   b 1   1d b   b 1d  A_2 =  d 1+b   1b d   d 1+b   1+b d   1d  and matrix B are chosen as identity matrices (see DLATM5).
Parameters:

NSIZE
NSIZE is INTEGER The maximum size of the matrices to use. NSIZE >= 0. If NSIZE = 0, no builtin tests matrices are used, but readin test matrices are used to test DGGESX.
NCMAXNCMAX is INTEGER Maximum allowable NMAX for generating Kroneker matrix in call to DLAKF2
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. THRESH >= 0.
NINNIN is INTEGER The FORTRAN unit number for reading in the data file of problems to solve.
NOUTNOUT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.)
AA is DOUBLE PRECISION array, dimension (LDA, NSIZE) Used to store the matrix whose eigenvalues are to be computed. On exit, A contains the last matrix actually used.
LDALDA is INTEGER The leading dimension of A, B, AI, BI, Z and Q, LDA >= max( 1, NSIZE ). For the readin test, LDA >= max( 1, N ), N is the size of the test matrices.
BB is DOUBLE PRECISION array, dimension (LDA, NSIZE) Used to store the matrix whose eigenvalues are to be computed. On exit, B contains the last matrix actually used.
AIAI is DOUBLE PRECISION array, dimension (LDA, NSIZE) Copy of A, modified by DGGESX.
BIBI is DOUBLE PRECISION array, dimension (LDA, NSIZE) Copy of B, modified by DGGESX.
ZZ is DOUBLE PRECISION array, dimension (LDA, NSIZE) Z holds the left Schur vectors computed by DGGESX.
QQ is DOUBLE PRECISION array, dimension (LDA, NSIZE) Q holds the right Schur vectors computed by DGGESX.
ALPHARALPHAR is DOUBLE PRECISION array, dimension (NSIZE)
ALPHAIALPHAI is DOUBLE PRECISION array, dimension (NSIZE)
BETABETA is DOUBLE PRECISION array, dimension (NSIZE) On exit, (ALPHAR + ALPHAI*i)/BETA are the eigenvalues.
CC is DOUBLE PRECISION array, dimension (LDC, LDC) Store the matrix generated by subroutine DLAKF2, this is the matrix formed by Kronecker products used for estimating DIF.
LDCLDC is INTEGER The leading dimension of C. LDC >= max(1, LDA*LDA/2 ).
SS is DOUBLE PRECISION array, dimension (LDC) Singular values of C
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The dimension of the array WORK. LWORK >= MAX( 5*NSIZE*NSIZE/2  2, 10*(NSIZE+1) )
IWORKIWORK is INTEGER array, dimension (LIWORK)
LIWORKLIWORK is INTEGER The dimension of the array IWORK. LIWORK >= NSIZE + 6.
BWORKBWORK is LOGICAL array, dimension (LDA)
INFOINFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value. > 0: A routine returned an error code.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine ddrgvx (integer NSIZE, double precision THRESH, integer NIN, integer NOUT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) AI, double precision, dimension( lda, * ) BI, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( lda, * ) VL, double precision, dimension( lda, * ) VR, integer ILO, integer IHI, double precision, dimension( * ) LSCALE, double precision, dimension( * ) RSCALE, double precision, dimension( * ) S, double precision, dimension( * ) DTRU, double precision, dimension( * ) DIF, double precision, dimension( * ) DIFTRU, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, double precision, dimension( 4 ) RESULT, logical, dimension( * ) BWORK, integer INFO)
DDRGVX
Purpose:

DDRGVX checks the nonsymmetric generalized eigenvalue problem expert driver DGGEVX. DGGEVX computes the generalized eigenvalues, (optionally) the left and/or right eigenvectors, (optionally) computes a balancing transformation to improve the conditioning, and (optionally) reciprocal condition numbers for the eigenvalues and eigenvectors. When DDRGVX is called with NSIZE > 0, two types of test matrix pairs are generated by the subroutine DLATM6 and test the driver DGGEVX. The test matrices have the known exact condition numbers for eigenvalues. For the condition numbers of the eigenvectors corresponding the first and last eigenvalues are also know ``exactly'' (see DLATM6). For each matrix pair, the following tests will be performed and compared with the threshold THRESH. (1) max over all left eigenvalue/vector pairs (beta/alpha,l) of  l**H * (beta A  alpha B)  / ( ulp max( beta A, alpha B ) ) where l**H is the conjugate tranpose of l. (2) max over all right eigenvalue/vector pairs (beta/alpha,r) of  (beta A  alpha B) r  / ( ulp max( beta A, alpha B ) ) (3) The condition number S(i) of eigenvalues computed by DGGEVX differs less than a factor THRESH from the exact S(i) (see DLATM6). (4) DIF(i) computed by DTGSNA differs less than a factor 10*THRESH from the exact value (for the 1st and 5th vectors only). Test Matrices ============= Two kinds of test matrix pairs (A, B) = inverse(YH) * (Da, Db) * inverse(X) are used in the tests: 1: Da = 1+a 0 0 0 0 Db = 1 0 0 0 0 0 2+a 0 0 0 0 1 0 0 0 0 0 3+a 0 0 0 0 1 0 0 0 0 0 4+a 0 0 0 0 1 0 0 0 0 0 5+a , 0 0 0 0 1 , and 2: Da = 1 1 0 0 0 Db = 1 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1+a 1+b 0 0 0 1 0 0 0 0 1b 1+a , 0 0 0 0 1 . In both cases the same inverse(YH) and inverse(X) are used to compute (A, B), giving the exact eigenvectors to (A,B) as (YH, X): YH: = 1 0 y y y X = 1 0 x x x 0 1 y y y 0 1 x x x 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1, 0 0 0 0 1 , where a, b, x and y will have all values independently of each other from { sqrt(sqrt(ULP)), 0.1, 1, 10, 1/sqrt(sqrt(ULP)) }.
Parameters:

NSIZE
NSIZE is INTEGER The number of sizes of matrices to use. NSIZE must be at least zero. If it is zero, no randomly generated matrices are tested, but any test matrices read from NIN will be tested.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
NINNIN is INTEGER The FORTRAN unit number for reading in the data file of problems to solve.
NOUTNOUT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.)
AA is DOUBLE PRECISION array, dimension (LDA, NSIZE) Used to hold the matrix whose eigenvalues are to be computed. On exit, A contains the last matrix actually used.
LDALDA is INTEGER The leading dimension of A, B, AI, BI, Ao, and Bo. It must be at least 1 and at least NSIZE.
BB is DOUBLE PRECISION array, dimension (LDA, NSIZE) Used to hold the matrix whose eigenvalues are to be computed. On exit, B contains the last matrix actually used.
AIAI is DOUBLE PRECISION array, dimension (LDA, NSIZE) Copy of A, modified by DGGEVX.
BIBI is DOUBLE PRECISION array, dimension (LDA, NSIZE) Copy of B, modified by DGGEVX.
ALPHARALPHAR is DOUBLE PRECISION array, dimension (NSIZE)
ALPHAIALPHAI is DOUBLE PRECISION array, dimension (NSIZE)
BETABETA is DOUBLE PRECISION array, dimension (NSIZE) On exit, (ALPHAR + ALPHAI*i)/BETA are the eigenvalues.
VLVL is DOUBLE PRECISION array, dimension (LDA, NSIZE) VL holds the left eigenvectors computed by DGGEVX.
VRVR is DOUBLE PRECISION array, dimension (LDA, NSIZE) VR holds the right eigenvectors computed by DGGEVX.
ILOILO is INTEGER
IHIIHI is INTEGER
LSCALELSCALE is DOUBLE PRECISION array, dimension (N)
RSCALERSCALE is DOUBLE PRECISION array, dimension (N)
SS is DOUBLE PRECISION array, dimension (N)
DTRUDTRU is DOUBLE PRECISION array, dimension (N)
DIFDIF is DOUBLE PRECISION array, dimension (N)
DIFTRUDIFTRU is DOUBLE PRECISION array, dimension (N)
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER Leading dimension of WORK. LWORK >= 2*N*N+12*N+16.
IWORKIWORK is INTEGER array, dimension (LIWORK)
LIWORKLIWORK is INTEGER Leading dimension of IWORK. Must be at least N+6.
RESULTRESULT is DOUBLE PRECISION array, dimension (4)
BWORKBWORK is LOGICAL array, dimension (N)
INFOINFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value. > 0: A routine returned an error code.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 April 2012
subroutine ddrvbd (integer NSIZES, integer, dimension( * ) MM, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldvt, * ) VT, integer LDVT, double precision, dimension( lda, * ) ASAV, double precision, dimension( ldu, * ) USAV, double precision, dimension( ldvt, * ) VTSAV, double precision, dimension( * ) S, double precision, dimension( * ) SSAV, double precision, dimension( * ) E, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer NOUT, integer INFO)
DDRVBD
Purpose:

DDRVBD checks the singular value decomposition (SVD) drivers DGESVD, DGESDD, DGESVJ, and DGEJSV. Both DGESVD and DGESDD factor A = U diag(S) VT, where U and VT are orthogonal and diag(S) is diagonal with the entries of the array S on its diagonal. The entries of S are the singular values, nonnegative and stored in decreasing order. U and VT can be optionally not computed, overwritten on A, or computed partially. A is M by N. Let MNMIN = min( M, N ). S has dimension MNMIN. U can be M by M or M by MNMIN. VT can be N by N or MNMIN by N. When DDRVBD is called, a number of matrix "sizes" (M's and N's) and a number of matrix "types" are specified. For each size (M,N) and each type of matrix, and for the minimal workspace as well as workspace adequate to permit blocking, an M x N matrix "A" will be generated and used to test the SVD routines. For each matrix, A will be factored as A = U diag(S) VT and the following 12 tests computed: Test for DGESVD: (1)  A  U diag(S) VT  / ( A max(M,N) ulp ) (2)  I  U'U  / ( M ulp ) (3)  I  VT VT'  / ( N ulp ) (4) S contains MNMIN nonnegative values in decreasing order. (Return 0 if true, 1/ULP if false.) (5)  U  Upartial  / ( M ulp ) where Upartial is a partially computed U. (6)  VT  VTpartial  / ( N ulp ) where VTpartial is a partially computed VT. (7)  S  Spartial  / ( MNMIN ulp S ) where Spartial is the vector of singular values from the partial SVD Test for DGESDD: (8)  A  U diag(S) VT  / ( A max(M,N) ulp ) (9)  I  U'U  / ( M ulp ) (10)  I  VT VT'  / ( N ulp ) (11) S contains MNMIN nonnegative values in decreasing order. (Return 0 if true, 1/ULP if false.) (12)  U  Upartial  / ( M ulp ) where Upartial is a partially computed U. (13)  VT  VTpartial  / ( N ulp ) where VTpartial is a partially computed VT. (14)  S  Spartial  / ( MNMIN ulp S ) where Spartial is the vector of singular values from the partial SVD Test for DGESVJ: (15)  A  U diag(S) VT  / ( A max(M,N) ulp ) (16)  I  U'U  / ( M ulp ) (17)  I  VT VT'  / ( N ulp ) (18) S contains MNMIN nonnegative values in decreasing order. (Return 0 if true, 1/ULP if false.) Test for DGEJSV: (19)  A  U diag(S) VT  / ( A max(M,N) ulp ) (20)  I  U'U  / ( M ulp ) (21)  I  VT VT'  / ( N ulp ) (22) S contains MNMIN nonnegative values in decreasing order. (Return 0 if true, 1/ULP if false.) Test for DGESVDX( 'V', 'V', 'A' )/DGESVDX( 'N', 'N', 'A' ) (23)  A  U diag(S) VT  / ( A max(M,N) ulp ) (24)  I  U'U  / ( M ulp ) (25)  I  VT VT'  / ( N ulp ) (26) S contains MNMIN nonnegative values in decreasing order. (Return 0 if true, 1/ULP if false.) (27)  U  Upartial  / ( M ulp ) where Upartial is a partially computed U. (28)  VT  VTpartial  / ( N ulp ) where VTpartial is a partially computed VT. (29)  S  Spartial  / ( MNMIN ulp S ) where Spartial is the vector of singular values from the partial SVD Test for DGESVDX( 'V', 'V', 'I' ) (30)  U' A VT'''  diag(S)  / ( A max(M,N) ulp ) (31)  I  U'U  / ( M ulp ) (32)  I  VT VT'  / ( N ulp ) Test for DGESVDX( 'V', 'V', 'V' ) (33)  U' A VT'''  diag(S)  / ( A max(M,N) ulp ) (34)  I  U'U  / ( M ulp ) (35)  I  VT VT'  / ( N ulp ) The "sizes" are specified by the arrays MM(1:NSIZES) and NN(1:NSIZES); the value of each element pair (MM(j),NN(j)) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) The zero matrix. (2) The identity matrix. (3) A matrix of the form U D V, where U and V are orthogonal and D has evenly spaced entries 1, ..., ULP with random signs on the diagonal. (4) Same as (3), but multiplied by the underflowthreshold / ULP. (5) Same as (3), but multiplied by the overflowthreshold * ULP.
Parameters:

NSIZES
NSIZES is INTEGER The number of matrix sizes (M,N) contained in the vectors MM and NN.
MMMM is INTEGER array, dimension (NSIZES) The values of the matrix row dimension M.
NNNN is INTEGER array, dimension (NSIZES) The values of the matrix column dimension N.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DDRVBD does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrices are in A and B. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size (m,n), a matrix of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry, the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. On exit, ISEED is changed and can be used in the next call to DDRVBD to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. The test ratios are scaled to be O(1), so THRESH should be a small multiple of 1, e.g., 10 or 100. To have every test ratio printed, use THRESH = 0.
AA is DOUBLE PRECISION array, dimension (LDA,NMAX) where NMAX is the maximum value of N in NN.
LDALDA is INTEGER The leading dimension of the array A. LDA >= max(1,MMAX), where MMAX is the maximum value of M in MM.
UU is DOUBLE PRECISION array, dimension (LDU,MMAX)
LDULDU is INTEGER The leading dimension of the array U. LDU >= max(1,MMAX).
VTVT is DOUBLE PRECISION array, dimension (LDVT,NMAX)
LDVTLDVT is INTEGER The leading dimension of the array VT. LDVT >= max(1,NMAX).
ASAVASAV is DOUBLE PRECISION array, dimension (LDA,NMAX)
USAVUSAV is DOUBLE PRECISION array, dimension (LDU,MMAX)
VTSAVVTSAV is DOUBLE PRECISION array, dimension (LDVT,NMAX)
SS is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
SSAVSSAV is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
EE is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The number of entries in WORK. This must be at least max(3*MN+MX,5*MN4)+2*MN**2 for all pairs pairs (MN,MX)=( min(MM(j),NN(j), max(MM(j),NN(j)) )
IWORKIWORK is INTEGER array, dimension at least 8*min(M,N)
NOUTNOUT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.)
INFOINFO is INTEGER If 0, then everything ran OK. 1: NSIZES < 0 2: Some MM(j) < 0 3: Some NN(j) < 0 4: NTYPES < 0 7: THRESH < 0 10: LDA < 1 or LDA < MMAX, where MMAX is max( MM(j) ). 12: LDU < 1 or LDU < MMAX. 14: LDVT < 1 or LDVT < NMAX, where NMAX is max( NN(j) ). 21: LWORK too small. If DLATMS, or DGESVD returns an error code, the absolute value of it is returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine ddrves (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( lda, * ) HT, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WRT, double precision, dimension( * ) WIT, double precision, dimension( ldvs, * ) VS, integer LDVS, double precision, dimension( 13 ) RESULT, double precision, dimension( * ) WORK, integer NWORK, integer, dimension( * ) IWORK, logical, dimension( * ) BWORK, integer INFO)
DDRVES
Purpose:

DDRVES checks the nonsymmetric eigenvalue (Schur form) problem driver DGEES. When DDRVES is called, a number of matrix "sizes" ("n's") and a number of matrix "types" are specified. For each size ("n") and each type of matrix, one matrix will be generated and used to test the nonsymmetric eigenroutines. For each matrix, 13 tests will be performed: (1) 0 if T is in Schur form, 1/ulp otherwise (no sorting of eigenvalues) (2)  A  VS T VS'  / ( n A ulp ) Here VS is the matrix of Schur eigenvectors, and T is in Schur form (no sorting of eigenvalues). (3)  I  VS VS'  / ( n ulp ) (no sorting of eigenvalues). (4) 0 if WR+sqrt(1)*WI are eigenvalues of T 1/ulp otherwise (no sorting of eigenvalues) (5) 0 if T(with VS) = T(without VS), 1/ulp otherwise (no sorting of eigenvalues) (6) 0 if eigenvalues(with VS) = eigenvalues(without VS), 1/ulp otherwise (no sorting of eigenvalues) (7) 0 if T is in Schur form, 1/ulp otherwise (with sorting of eigenvalues) (8)  A  VS T VS'  / ( n A ulp ) Here VS is the matrix of Schur eigenvectors, and T is in Schur form (with sorting of eigenvalues). (9)  I  VS VS'  / ( n ulp ) (with sorting of eigenvalues). (10) 0 if WR+sqrt(1)*WI are eigenvalues of T 1/ulp otherwise (with sorting of eigenvalues) (11) 0 if T(with VS) = T(without VS), 1/ulp otherwise (with sorting of eigenvalues) (12) 0 if eigenvalues(with VS) = eigenvalues(without VS), 1/ulp otherwise (with sorting of eigenvalues) (13) if sorting worked and SDIM is the number of eigenvalues which were SELECTed The "sizes" are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) The zero matrix. (2) The identity matrix. (3) A (transposed) Jordan block, with 1's on the diagonal. (4) A diagonal matrix with evenly spaced entries 1, ..., ULP and random signs. (ULP = (first number larger than 1)  1 ) (5) A diagonal matrix with geometrically spaced entries 1, ..., ULP and random signs. (6) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP and random signs. (7) Same as (4), but multiplied by a constant near the overflow threshold (8) Same as (4), but multiplied by a constant near the underflow threshold (9) A matrix of the form U' T U, where U is orthogonal and T has evenly spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (10) A matrix of the form U' T U, where U is orthogonal and T has geometrically spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (11) A matrix of the form U' T U, where U is orthogonal and T has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (12) A matrix of the form U' T U, where U is orthogonal and T has real or complex conjugate paired eigenvalues randomly chosen from ( ULP, 1 ) and random O(1) entries in the upper triangle. (13) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (14) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has geometrically spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (15) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (16) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has real or complex conjugate paired eigenvalues randomly chosen from ( ULP, 1 ) and random O(1) entries in the upper triangle. (17) Same as (16), but multiplied by a constant near the overflow threshold (18) Same as (16), but multiplied by a constant near the underflow threshold (19) Nonsymmetric matrix with random entries chosen from (1,1). If N is at least 4, all entries in first two rows and last row, and first column and last two columns are zero. (20) Same as (19), but multiplied by a constant near the overflow threshold (21) Same as (19), but multiplied by a constant near the underflow threshold
Parameters:

NSIZES
NSIZES is INTEGER The number of sizes of matrices to use. If it is zero, DDRVES does nothing. It must be at least zero.
NNNN is INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. The values must be at least zero.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DDRVES does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DDRVES to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns INFO not equal to 0.)
AA is DOUBLE PRECISION array, dimension (LDA, max(NN)) Used to hold the matrix whose eigenvalues are to be computed. On exit, A contains the last matrix actually used.
LDALDA is INTEGER The leading dimension of A, and H. LDA must be at least 1 and at least max(NN).
HH is DOUBLE PRECISION array, dimension (LDA, max(NN)) Another copy of the test matrix A, modified by DGEES.
HTHT is DOUBLE PRECISION array, dimension (LDA, max(NN)) Yet another copy of the test matrix A, modified by DGEES.
WRWR is DOUBLE PRECISION array, dimension (max(NN))
WIWI is DOUBLE PRECISION array, dimension (max(NN)) The real and imaginary parts of the eigenvalues of A. On exit, WR + WI*i are the eigenvalues of the matrix in A.
WRTWRT is DOUBLE PRECISION array, dimension (max(NN))
WITWIT is DOUBLE PRECISION array, dimension (max(NN)) Like WR, WI, these arrays contain the eigenvalues of A, but those computed when DGEES only computes a partial eigendecomposition, i.e. not Schur vectors
VSVS is DOUBLE PRECISION array, dimension (LDVS, max(NN)) VS holds the computed Schur vectors.
LDVSLDVS is INTEGER Leading dimension of VS. Must be at least max(1,max(NN)).
RESULTRESULT is DOUBLE PRECISION array, dimension (13) The values computed by the 13 tests described above. The values are currently limited to 1/ulp, to avoid overflow.
WORKWORK is DOUBLE PRECISION array, dimension (NWORK)
NWORKNWORK is INTEGER The number of entries in WORK. This must be at least 5*NN(j)+2*NN(j)**2 for all j.
IWORKIWORK is INTEGER array, dimension (max(NN))
BWORKBWORK is LOGICAL array, dimension (max(NN))
INFOINFO is INTEGER If 0, then everything ran OK. 1: NSIZES < 0 2: Some NN(j) < 0 3: NTYPES < 0 6: THRESH < 0 9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ). 17: LDVS < 1 or LDVS < NMAX, where NMAX is max( NN(j) ). 20: NWORK too small. If DLATMR, SLATMS, SLATME or DGEES returns an error code, the absolute value of it is returned.  Some Local Variables and Parameters:      ZERO, ONE Real 0 and 1. MAXTYP The number of types defined. NMAX Largest value in NN. NERRS The number of tests which have exceeded THRESH COND, CONDS, IMODE Values to be passed to the matrix generators. ANORM Norm of A; passed to matrix generators. OVFL, UNFL Overflow and underflow thresholds. ULP, ULPINV Finest relative precision and its inverse. RTULP, RTULPI Square roots of the previous 4 values. The following four arrays decode JTYPE: KTYPE(j) The general type (110) for type "j". KMODE(j) The MODE value to be passed to the matrix generator for type "j". KMAGN(j) The order of magnitude ( O(1), O(overflow^(1/2) ), O(underflow^(1/2) ) KCONDS(j) Selectw whether CONDS is to be 1 or 1/sqrt(ulp). (0 means irrelevant.)
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine ddrvev (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WR1, double precision, dimension( * ) WI1, double precision, dimension( ldvl, * ) VL, integer LDVL, double precision, dimension( ldvr, * ) VR, integer LDVR, double precision, dimension( ldlre, * ) LRE, integer LDLRE, double precision, dimension( 7 ) RESULT, double precision, dimension( * ) WORK, integer NWORK, integer, dimension( * ) IWORK, integer INFO)
DDRVEV
Purpose:

DDRVEV checks the nonsymmetric eigenvalue problem driver DGEEV. When DDRVEV is called, a number of matrix "sizes" ("n's") and a number of matrix "types" are specified. For each size ("n") and each type of matrix, one matrix will be generated and used to test the nonsymmetric eigenroutines. For each matrix, 7 tests will be performed: (1)  A * VR  VR * W  / ( n A ulp ) Here VR is the matrix of unit right eigenvectors. W is a block diagonal matrix, with a 1x1 block for each real eigenvalue and a 2x2 block for each complex conjugate pair. If eigenvalues j and j+1 are a complex conjugate pair, so WR(j) = WR(j+1) = wr and WI(j) =  WI(j+1) = wi, then the 2 x 2 block corresponding to the pair will be: ( wr wi ) ( wi wr ) Such a block multiplying an n x 2 matrix ( ur ui ) on the right will be the same as multiplying ur + i*ui by wr + i*wi. (2)  A**H * VL  VL * W**H  / ( n A ulp ) Here VL is the matrix of unit left eigenvectors, A**H is the conjugate transpose of A, and W is as above. (3)  VR(i)  1  / ulp and whether largest component real VR(i) denotes the ith column of VR. (4)  VL(i)  1  / ulp and whether largest component real VL(i) denotes the ith column of VL. (5) W(full) = W(partial) W(full) denotes the eigenvalues computed when both VR and VL are also computed, and W(partial) denotes the eigenvalues computed when only W, only W and VR, or only W and VL are computed. (6) VR(full) = VR(partial) VR(full) denotes the right eigenvectors computed when both VR and VL are computed, and VR(partial) denotes the result when only VR is computed. (7) VL(full) = VL(partial) VL(full) denotes the left eigenvectors computed when both VR and VL are also computed, and VL(partial) denotes the result when only VL is computed. The "sizes" are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) The zero matrix. (2) The identity matrix. (3) A (transposed) Jordan block, with 1's on the diagonal. (4) A diagonal matrix with evenly spaced entries 1, ..., ULP and random signs. (ULP = (first number larger than 1)  1 ) (5) A diagonal matrix with geometrically spaced entries 1, ..., ULP and random signs. (6) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP and random signs. (7) Same as (4), but multiplied by a constant near the overflow threshold (8) Same as (4), but multiplied by a constant near the underflow threshold (9) A matrix of the form U' T U, where U is orthogonal and T has evenly spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (10) A matrix of the form U' T U, where U is orthogonal and T has geometrically spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (11) A matrix of the form U' T U, where U is orthogonal and T has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (12) A matrix of the form U' T U, where U is orthogonal and T has real or complex conjugate paired eigenvalues randomly chosen from ( ULP, 1 ) and random O(1) entries in the upper triangle. (13) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (14) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has geometrically spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (15) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (16) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has real or complex conjugate paired eigenvalues randomly chosen from ( ULP, 1 ) and random O(1) entries in the upper triangle. (17) Same as (16), but multiplied by a constant near the overflow threshold (18) Same as (16), but multiplied by a constant near the underflow threshold (19) Nonsymmetric matrix with random entries chosen from (1,1). If N is at least 4, all entries in first two rows and last row, and first column and last two columns are zero. (20) Same as (19), but multiplied by a constant near the overflow threshold (21) Same as (19), but multiplied by a constant near the underflow threshold
Parameters:

NSIZES
NSIZES is INTEGER The number of sizes of matrices to use. If it is zero, DDRVEV does nothing. It must be at least zero.
NNNN is INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. The values must be at least zero.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. If it is zero, DDRVEV does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DDRVEV to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns INFO not equal to 0.)
AA is DOUBLE PRECISION array, dimension (LDA, max(NN)) Used to hold the matrix whose eigenvalues are to be computed. On exit, A contains the last matrix actually used.
LDALDA is INTEGER The leading dimension of A, and H. LDA must be at least 1 and at least max(NN).
HH is DOUBLE PRECISION array, dimension (LDA, max(NN)) Another copy of the test matrix A, modified by DGEEV.
WRWR is DOUBLE PRECISION array, dimension (max(NN))
WIWI is DOUBLE PRECISION array, dimension (max(NN)) The real and imaginary parts of the eigenvalues of A. On exit, WR + WI*i are the eigenvalues of the matrix in A.
WR1WR1 is DOUBLE PRECISION array, dimension (max(NN))
WI1WI1 is DOUBLE PRECISION array, dimension (max(NN)) Like WR, WI, these arrays contain the eigenvalues of A, but those computed when DGEEV only computes a partial eigendecomposition, i.e. not the eigenvalues and left and right eigenvectors.
VLVL is DOUBLE PRECISION array, dimension (LDVL, max(NN)) VL holds the computed left eigenvectors.
LDVLLDVL is INTEGER Leading dimension of VL. Must be at least max(1,max(NN)).
VRVR is DOUBLE PRECISION array, dimension (LDVR, max(NN)) VR holds the computed right eigenvectors.
LDVRLDVR is INTEGER Leading dimension of VR. Must be at least max(1,max(NN)).
LRELRE is DOUBLE PRECISION array, dimension (LDLRE,max(NN)) LRE holds the computed right or left eigenvectors.
LDLRELDLRE is INTEGER Leading dimension of LRE. Must be at least max(1,max(NN)).
RESULTRESULT is DOUBLE PRECISION array, dimension (7) The values computed by the seven tests described above. The values are currently limited to 1/ulp, to avoid overflow.
WORKWORK is DOUBLE PRECISION array, dimension (NWORK)
NWORKNWORK is INTEGER The number of entries in WORK. This must be at least 5*NN(j)+2*NN(j)**2 for all j.
IWORKIWORK is INTEGER array, dimension (max(NN))
INFOINFO is INTEGER If 0, then everything ran OK. 1: NSIZES < 0 2: Some NN(j) < 0 3: NTYPES < 0 6: THRESH < 0 9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ). 16: LDVL < 1 or LDVL < NMAX, where NMAX is max( NN(j) ). 18: LDVR < 1 or LDVR < NMAX, where NMAX is max( NN(j) ). 20: LDLRE < 1 or LDLRE < NMAX, where NMAX is max( NN(j) ). 23: NWORK too small. If DLATMR, SLATMS, SLATME or DGEEV returns an error code, the absolute value of it is returned.  Some Local Variables and Parameters:      ZERO, ONE Real 0 and 1. MAXTYP The number of types defined. NMAX Largest value in NN. NERRS The number of tests which have exceeded THRESH COND, CONDS, IMODE Values to be passed to the matrix generators. ANORM Norm of A; passed to matrix generators. OVFL, UNFL Overflow and underflow thresholds. ULP, ULPINV Finest relative precision and its inverse. RTULP, RTULPI Square roots of the previous 4 values. The following four arrays decode JTYPE: KTYPE(j) The general type (110) for type "j". KMODE(j) The MODE value to be passed to the matrix generator for type "j". KMAGN(j) The order of magnitude ( O(1), O(overflow^(1/2) ), O(underflow^(1/2) ) KCONDS(j) Selectw whether CONDS is to be 1 or 1/sqrt(ulp). (0 means irrelevant.)
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine ddrvsg (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) D, double precision, dimension( ldz, * ) Z, integer LDZ, double precision, dimension( lda, * ) AB, double precision, dimension( ldb, * ) BB, double precision, dimension( * ) AP, double precision, dimension( * ) BP, double precision, dimension( * ) WORK, integer NWORK, integer, dimension( * ) IWORK, integer LIWORK, double precision, dimension( * ) RESULT, integer INFO)
DDRVSG
Purpose:

DDRVSG checks the real symmetric generalized eigenproblem drivers. DSYGV computes all eigenvalues and, optionally, eigenvectors of a real symmetricdefinite generalized eigenproblem. DSYGVD computes all eigenvalues and, optionally, eigenvectors of a real symmetricdefinite generalized eigenproblem using a divide and conquer algorithm. DSYGVX computes selected eigenvalues and, optionally, eigenvectors of a real symmetricdefinite generalized eigenproblem. DSPGV computes all eigenvalues and, optionally, eigenvectors of a real symmetricdefinite generalized eigenproblem in packed storage. DSPGVD computes all eigenvalues and, optionally, eigenvectors of a real symmetricdefinite generalized eigenproblem in packed storage using a divide and conquer algorithm. DSPGVX computes selected eigenvalues and, optionally, eigenvectors of a real symmetricdefinite generalized eigenproblem in packed storage. DSBGV computes all eigenvalues and, optionally, eigenvectors of a real symmetricdefinite banded generalized eigenproblem. DSBGVD computes all eigenvalues and, optionally, eigenvectors of a real symmetricdefinite banded generalized eigenproblem using a divide and conquer algorithm. DSBGVX computes selected eigenvalues and, optionally, eigenvectors of a real symmetricdefinite banded generalized eigenproblem. When DDRVSG is called, a number of matrix "sizes" ("n's") and a number of matrix "types" are specified. For each size ("n") and each type of matrix, one matrix A of the given type will be generated; a random wellconditioned matrix B is also generated and the pair (A,B) is used to test the drivers. For each pair (A,B), the following tests are performed: (1) DSYGV with ITYPE = 1 and UPLO ='U':  A Z  B Z D  / ( A Z n ulp ) (2) as (1) but calling DSPGV (3) as (1) but calling DSBGV (4) as (1) but with UPLO = 'L' (5) as (4) but calling DSPGV (6) as (4) but calling DSBGV (7) DSYGV with ITYPE = 2 and UPLO ='U':  A B Z  Z D  / ( A Z n ulp ) (8) as (7) but calling DSPGV (9) as (7) but with UPLO = 'L' (10) as (9) but calling DSPGV (11) DSYGV with ITYPE = 3 and UPLO ='U':  B A Z  Z D  / ( A Z n ulp ) (12) as (11) but calling DSPGV (13) as (11) but with UPLO = 'L' (14) as (13) but calling DSPGV DSYGVD, DSPGVD and DSBGVD performed the same 14 tests. DSYGVX, DSPGVX and DSBGVX performed the above 14 tests with the parameter RANGE = 'A', 'N' and 'I', respectively. The "sizes" are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. This type is used for the matrix A which has halfbandwidth KA. B is generated as a wellconditioned positive definite matrix with halfbandwidth KB (<= KA). Currently, the list of possible types for A is: (1) The zero matrix. (2) The identity matrix. (3) A diagonal matrix with evenly spaced entries 1, ..., ULP and random signs. (ULP = (first number larger than 1)  1 ) (4) A diagonal matrix with geometrically spaced entries 1, ..., ULP and random signs. (5) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP and random signs. (6) Same as (4), but multiplied by SQRT( overflow threshold ) (7) Same as (4), but multiplied by SQRT( underflow threshold ) (8) A matrix of the form U* D U, where U is orthogonal and D has evenly spaced entries 1, ..., ULP with random signs on the diagonal. (9) A matrix of the form U* D U, where U is orthogonal and D has geometrically spaced entries 1, ..., ULP with random signs on the diagonal. (10) A matrix of the form U* D U, where U is orthogonal and D has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal. (11) Same as (8), but multiplied by SQRT( overflow threshold ) (12) Same as (8), but multiplied by SQRT( underflow threshold ) (13) symmetric matrix with random entries chosen from (1,1). (14) Same as (13), but multiplied by SQRT( overflow threshold ) (15) Same as (13), but multiplied by SQRT( underflow threshold) (16) Same as (8), but with KA = 1 and KB = 1 (17) Same as (8), but with KA = 2 and KB = 1 (18) Same as (8), but with KA = 2 and KB = 2 (19) Same as (8), but with KA = 3 and KB = 1 (20) Same as (8), but with KA = 3 and KB = 2 (21) Same as (8), but with KA = 3 and KB = 3
NSIZES INTEGER The number of sizes of matrices to use. If it is zero, DDRVSG does nothing. It must be at least zero. Not modified. NN INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. The values must be at least zero. Not modified. NTYPES INTEGER The number of elements in DOTYPE. If it is zero, DDRVSG does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. . Not modified. DOTYPE LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored. Not modified. ISEED INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DDRVSG to continue the same random number sequence. Modified. THRESH DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero. Not modified. NOUNIT INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.) Not modified. A DOUBLE PRECISION array, dimension (LDA , max(NN)) Used to hold the matrix whose eigenvalues are to be computed. On exit, A contains the last matrix actually used. Modified. LDA INTEGER The leading dimension of A and AB. It must be at least 1 and at least max( NN ). Not modified. B DOUBLE PRECISION array, dimension (LDB , max(NN)) Used to hold the symmetric positive definite matrix for the generailzed problem. On exit, B contains the last matrix actually used. Modified. LDB INTEGER The leading dimension of B and BB. It must be at least 1 and at least max( NN ). Not modified. D DOUBLE PRECISION array, dimension (max(NN)) The eigenvalues of A. On exit, the eigenvalues in D correspond with the matrix in A. Modified. Z DOUBLE PRECISION array, dimension (LDZ, max(NN)) The matrix of eigenvectors. Modified. LDZ INTEGER The leading dimension of Z. It must be at least 1 and at least max( NN ). Not modified. AB DOUBLE PRECISION array, dimension (LDA, max(NN)) Workspace. Modified. BB DOUBLE PRECISION array, dimension (LDB, max(NN)) Workspace. Modified. AP DOUBLE PRECISION array, dimension (max(NN)**2) Workspace. Modified. BP DOUBLE PRECISION array, dimension (max(NN)**2) Workspace. Modified. WORK DOUBLE PRECISION array, dimension (NWORK) Workspace. Modified. NWORK INTEGER The number of entries in WORK. This must be at least 1+5*N+2*N*lg(N)+3*N**2 where N = max( NN(j) ) and lg( N ) = smallest integer k such that 2**k >= N. Not modified. IWORK INTEGER array, dimension (LIWORK) Workspace. Modified. LIWORK INTEGER The number of entries in WORK. This must be at least 6*N. Not modified. RESULT DOUBLE PRECISION array, dimension (70) The values computed by the 70 tests described above. Modified. INFO INTEGER If 0, then everything ran OK. 1: NSIZES < 0 2: Some NN(j) < 0 3: NTYPES < 0 5: THRESH < 0 9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ). 16: LDZ < 1 or LDZ < NMAX. 21: NWORK too small. 23: LIWORK too small. If DLATMR, SLATMS, DSYGV, DSPGV, DSBGV, SSYGVD, SSPGVD, DSBGVD, DSYGVX, DSPGVX or SSBGVX returns an error code, the absolute value of it is returned. Modified.  Some Local Variables and Parameters:      ZERO, ONE Real 0 and 1. MAXTYP The number of types defined. NTEST The number of tests that have been run on this matrix. NTESTT The total number of tests for this call. NMAX Largest value in NN. NMATS The number of matrices generated so far. NERRS The number of tests which have exceeded THRESH so far (computed by DLAFTS). COND, IMODE Values to be passed to the matrix generators. ANORM Norm of A; passed to matrix generators. OVFL, UNFL Overflow and underflow thresholds. ULP, ULPINV Finest relative precision and its inverse. RTOVFL, RTUNFL Square roots of the previous 2 values. The following four arrays decode JTYPE: KTYPE(j) The general type (110) for type "j". KMODE(j) The MODE value to be passed to the matrix generator for type "j". KMAGN(j) The order of magnitude ( O(1), O(overflow^(1/2) ), O(underflow^(1/2) )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine ddrvst (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D1, double precision, dimension( * ) D2, double precision, dimension( * ) D3, double precision, dimension( * ) D4, double precision, dimension( * ) EVEIGS, double precision, dimension( * ) WA1, double precision, dimension( * ) WA2, double precision, dimension( * ) WA3, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldu, * ) V, double precision, dimension( * ) TAU, double precision, dimension( ldu, * ) Z, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, double precision, dimension( * ) RESULT, integer INFO)
DDRVST
Purpose:

DDRVST checks the symmetric eigenvalue problem drivers. DSTEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix. DSTEVX computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix. DSTEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix using the Relatively Robust Representation where it can. DSYEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix. DSYEVX computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix. DSYEVR computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix using the Relatively Robust Representation where it can. DSPEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix in packed storage. DSPEVX computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix in packed storage. DSBEV computes all eigenvalues and, optionally, eigenvectors of a real symmetric band matrix. DSBEVX computes selected eigenvalues and, optionally, eigenvectors of a real symmetric band matrix. DSYEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix using a divide and conquer algorithm. DSPEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix in packed storage, using a divide and conquer algorithm. DSBEVD computes all eigenvalues and, optionally, eigenvectors of a real symmetric band matrix, using a divide and conquer algorithm. When DDRVST is called, a number of matrix "sizes" ("n's") and a number of matrix "types" are specified. For each size ("n") and each type of matrix, one matrix will be generated and used to test the appropriate drivers. For each matrix and each driver routine called, the following tests will be performed: (1)  A  Z D Z'  / ( A n ulp ) (2)  I  Z Z'  / ( n ulp ) (3)  D1  D2  / ( D1 ulp ) where Z is the matrix of eigenvectors returned when the eigenvector option is given and D1 and D2 are the eigenvalues returned with and without the eigenvector option. The "sizes" are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) The zero matrix. (2) The identity matrix. (3) A diagonal matrix with evenly spaced eigenvalues 1, ..., ULP and random signs. (ULP = (first number larger than 1)  1 ) (4) A diagonal matrix with geometrically spaced eigenvalues 1, ..., ULP and random signs. (5) A diagonal matrix with "clustered" eigenvalues 1, ULP, ..., ULP and random signs. (6) Same as (4), but multiplied by SQRT( overflow threshold ) (7) Same as (4), but multiplied by SQRT( underflow threshold ) (8) A matrix of the form U' D U, where U is orthogonal and D has evenly spaced entries 1, ..., ULP with random signs on the diagonal. (9) A matrix of the form U' D U, where U is orthogonal and D has geometrically spaced entries 1, ..., ULP with random signs on the diagonal. (10) A matrix of the form U' D U, where U is orthogonal and D has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal. (11) Same as (8), but multiplied by SQRT( overflow threshold ) (12) Same as (8), but multiplied by SQRT( underflow threshold ) (13) Symmetric matrix with random entries chosen from (1,1). (14) Same as (13), but multiplied by SQRT( overflow threshold ) (15) Same as (13), but multiplied by SQRT( underflow threshold ) (16) A band matrix with half bandwidth randomly chosen between 0 and N1, with evenly spaced eigenvalues 1, ..., ULP with random signs. (17) Same as (16), but multiplied by SQRT( overflow threshold ) (18) Same as (16), but multiplied by SQRT( underflow threshold )
NSIZES INTEGER The number of sizes of matrices to use. If it is zero, DDRVST does nothing. It must be at least zero. Not modified. NN INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. The values must be at least zero. Not modified. NTYPES INTEGER The number of elements in DOTYPE. If it is zero, DDRVST does nothing. It must be at least zero. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. . Not modified. DOTYPE LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored. Not modified. ISEED INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DDRVST to continue the same random number sequence. Modified. THRESH DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero. Not modified. NOUNIT INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns IINFO not equal to 0.) Not modified. A DOUBLE PRECISION array, dimension (LDA , max(NN)) Used to hold the matrix whose eigenvalues are to be computed. On exit, A contains the last matrix actually used. Modified. LDA INTEGER The leading dimension of A. It must be at least 1 and at least max( NN ). Not modified. D1 DOUBLE PRECISION array, dimension (max(NN)) The eigenvalues of A, as computed by DSTEQR simlutaneously with Z. On exit, the eigenvalues in D1 correspond with the matrix in A. Modified. D2 DOUBLE PRECISION array, dimension (max(NN)) The eigenvalues of A, as computed by DSTEQR if Z is not computed. On exit, the eigenvalues in D2 correspond with the matrix in A. Modified. D3 DOUBLE PRECISION array, dimension (max(NN)) The eigenvalues of A, as computed by DSTERF. On exit, the eigenvalues in D3 correspond with the matrix in A. Modified. D4 DOUBLE PRECISION array, dimension EVEIGS DOUBLE PRECISION array, dimension (max(NN)) The eigenvalues as computed by DSTEV('N', ... ) (I reserve the right to change this to the output of whichever algorithm computes the most accurate eigenvalues). WA1 DOUBLE PRECISION array, dimension WA2 DOUBLE PRECISION array, dimension WA3 DOUBLE PRECISION array, dimension U DOUBLE PRECISION array, dimension (LDU, max(NN)) The orthogonal matrix computed by DSYTRD + DORGTR. Modified. LDU INTEGER The leading dimension of U, Z, and V. It must be at least 1 and at least max( NN ). Not modified. V DOUBLE PRECISION array, dimension (LDU, max(NN)) The Housholder vectors computed by DSYTRD in reducing A to tridiagonal form. Modified. TAU DOUBLE PRECISION array, dimension (max(NN)) The Householder factors computed by DSYTRD in reducing A to tridiagonal form. Modified. Z DOUBLE PRECISION array, dimension (LDU, max(NN)) The orthogonal matrix of eigenvectors computed by DSTEQR, DPTEQR, and DSTEIN. Modified. WORK DOUBLE PRECISION array, dimension (LWORK) Workspace. Modified. LWORK INTEGER The number of entries in WORK. This must be at least 1 + 4 * Nmax + 2 * Nmax * lg Nmax + 4 * Nmax**2 where Nmax = max( NN(j), 2 ) and lg = log base 2. Not modified. IWORK INTEGER array, dimension (6 + 6*Nmax + 5 * Nmax * lg Nmax ) where Nmax = max( NN(j), 2 ) and lg = log base 2. Workspace. Modified. RESULT DOUBLE PRECISION array, dimension (105) The values computed by the tests described above. The values are currently limited to 1/ulp, to avoid overflow. Modified. INFO INTEGER If 0, then everything ran OK. 1: NSIZES < 0 2: Some NN(j) < 0 3: NTYPES < 0 5: THRESH < 0 9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ). 16: LDU < 1 or LDU < NMAX. 21: LWORK too small. If DLATMR, DLATMS, DSYTRD, DORGTR, DSTEQR, DSTERF, or DORMTR returns an error code, the absolute value of it is returned. Modified.  Some Local Variables and Parameters:      ZERO, ONE Real 0 and 1. MAXTYP The number of types defined. NTEST The number of tests performed, or which can be performed so far, for the current matrix. NTESTT The total number of tests performed so far. NMAX Largest value in NN. NMATS The number of matrices generated so far. NERRS The number of tests which have exceeded THRESH so far (computed by DLAFTS). COND, IMODE Values to be passed to the matrix generators. ANORM Norm of A; passed to matrix generators. OVFL, UNFL Overflow and underflow thresholds. ULP, ULPINV Finest relative precision and its inverse. RTOVFL, RTUNFL Square roots of the previous 2 values. The following four arrays decode JTYPE: KTYPE(j) The general type (110) for type "j". KMODE(j) The MODE value to be passed to the matrix generator for type "j". KMAGN(j) The order of magnitude ( O(1), O(overflow^(1/2) ), O(underflow^(1/2) ) The tests performed are: Routine tested 1=  A  U S U'  / ( A n ulp ) DSTEV('V', ... ) 2=  I  U U'  / ( n ulp ) DSTEV('V', ... ) 3= D(with Z)  D(w/o Z) / (D ulp) DSTEV('N', ... ) 4=  A  U S U'  / ( A n ulp ) DSTEVX('V','A', ... ) 5=  I  U U'  / ( n ulp ) DSTEVX('V','A', ... ) 6= D(with Z)  EVEIGS / (D ulp) DSTEVX('N','A', ... ) 7=  A  U S U'  / ( A n ulp ) DSTEVR('V','A', ... ) 8=  I  U U'  / ( n ulp ) DSTEVR('V','A', ... ) 9= D(with Z)  EVEIGS / (D ulp) DSTEVR('N','A', ... ) 10=  A  U S U'  / ( A n ulp ) DSTEVX('V','I', ... ) 11=  I  U U'  / ( n ulp ) DSTEVX('V','I', ... ) 12= D(with Z)  D(w/o Z) / (D ulp) DSTEVX('N','I', ... ) 13=  A  U S U'  / ( A n ulp ) DSTEVX('V','V', ... ) 14=  I  U U'  / ( n ulp ) DSTEVX('V','V', ... ) 15= D(with Z)  D(w/o Z) / (D ulp) DSTEVX('N','V', ... ) 16=  A  U S U'  / ( A n ulp ) DSTEVD('V', ... ) 17=  I  U U'  / ( n ulp ) DSTEVD('V', ... ) 18= D(with Z)  EVEIGS / (D ulp) DSTEVD('N', ... ) 19=  A  U S U'  / ( A n ulp ) DSTEVR('V','I', ... ) 20=  I  U U'  / ( n ulp ) DSTEVR('V','I', ... ) 21= D(with Z)  D(w/o Z) / (D ulp) DSTEVR('N','I', ... ) 22=  A  U S U'  / ( A n ulp ) DSTEVR('V','V', ... ) 23=  I  U U'  / ( n ulp ) DSTEVR('V','V', ... ) 24= D(with Z)  D(w/o Z) / (D ulp) DSTEVR('N','V', ... ) 25=  A  U S U'  / ( A n ulp ) DSYEV('L','V', ... ) 26=  I  U U'  / ( n ulp ) DSYEV('L','V', ... ) 27= D(with Z)  D(w/o Z) / (D ulp) DSYEV('L','N', ... ) 28=  A  U S U'  / ( A n ulp ) DSYEVX('L','V','A', ... ) 29=  I  U U'  / ( n ulp ) DSYEVX('L','V','A', ... ) 30= D(with Z)  D(w/o Z) / (D ulp) DSYEVX('L','N','A', ... ) 31=  A  U S U'  / ( A n ulp ) DSYEVX('L','V','I', ... ) 32=  I  U U'  / ( n ulp ) DSYEVX('L','V','I', ... ) 33= D(with Z)  D(w/o Z) / (D ulp) DSYEVX('L','N','I', ... ) 34=  A  U S U'  / ( A n ulp ) DSYEVX('L','V','V', ... ) 35=  I  U U'  / ( n ulp ) DSYEVX('L','V','V', ... ) 36= D(with Z)  D(w/o Z) / (D ulp) DSYEVX('L','N','V', ... ) 37=  A  U S U'  / ( A n ulp ) DSPEV('L','V', ... ) 38=  I  U U'  / ( n ulp ) DSPEV('L','V', ... ) 39= D(with Z)  D(w/o Z) / (D ulp) DSPEV('L','N', ... ) 40=  A  U S U'  / ( A n ulp ) DSPEVX('L','V','A', ... ) 41=  I  U U'  / ( n ulp ) DSPEVX('L','V','A', ... ) 42= D(with Z)  D(w/o Z) / (D ulp) DSPEVX('L','N','A', ... ) 43=  A  U S U'  / ( A n ulp ) DSPEVX('L','V','I', ... ) 44=  I  U U'  / ( n ulp ) DSPEVX('L','V','I', ... ) 45= D(with Z)  D(w/o Z) / (D ulp) DSPEVX('L','N','I', ... ) 46=  A  U S U'  / ( A n ulp ) DSPEVX('L','V','V', ... ) 47=  I  U U'  / ( n ulp ) DSPEVX('L','V','V', ... ) 48= D(with Z)  D(w/o Z) / (D ulp) DSPEVX('L','N','V', ... ) 49=  A  U S U'  / ( A n ulp ) DSBEV('L','V', ... ) 50=  I  U U'  / ( n ulp ) DSBEV('L','V', ... ) 51= D(with Z)  D(w/o Z) / (D ulp) DSBEV('L','N', ... ) 52=  A  U S U'  / ( A n ulp ) DSBEVX('L','V','A', ... ) 53=  I  U U'  / ( n ulp ) DSBEVX('L','V','A', ... ) 54= D(with Z)  D(w/o Z) / (D ulp) DSBEVX('L','N','A', ... ) 55=  A  U S U'  / ( A n ulp ) DSBEVX('L','V','I', ... ) 56=  I  U U'  / ( n ulp ) DSBEVX('L','V','I', ... ) 57= D(with Z)  D(w/o Z) / (D ulp) DSBEVX('L','N','I', ... ) 58=  A  U S U'  / ( A n ulp ) DSBEVX('L','V','V', ... ) 59=  I  U U'  / ( n ulp ) DSBEVX('L','V','V', ... ) 60= D(with Z)  D(w/o Z) / (D ulp) DSBEVX('L','N','V', ... ) 61=  A  U S U'  / ( A n ulp ) DSYEVD('L','V', ... ) 62=  I  U U'  / ( n ulp ) DSYEVD('L','V', ... ) 63= D(with Z)  D(w/o Z) / (D ulp) DSYEVD('L','N', ... ) 64=  A  U S U'  / ( A n ulp ) DSPEVD('L','V', ... ) 65=  I  U U'  / ( n ulp ) DSPEVD('L','V', ... ) 66= D(with Z)  D(w/o Z) / (D ulp) DSPEVD('L','N', ... ) 67=  A  U S U'  / ( A n ulp ) DSBEVD('L','V', ... ) 68=  I  U U'  / ( n ulp ) DSBEVD('L','V', ... ) 69= D(with Z)  D(w/o Z) / (D ulp) DSBEVD('L','N', ... ) 70=  A  U S U'  / ( A n ulp ) DSYEVR('L','V','A', ... ) 71=  I  U U'  / ( n ulp ) DSYEVR('L','V','A', ... ) 72= D(with Z)  D(w/o Z) / (D ulp) DSYEVR('L','N','A', ... ) 73=  A  U S U'  / ( A n ulp ) DSYEVR('L','V','I', ... ) 74=  I  U U'  / ( n ulp ) DSYEVR('L','V','I', ... ) 75= D(with Z)  D(w/o Z) / (D ulp) DSYEVR('L','N','I', ... ) 76=  A  U S U'  / ( A n ulp ) DSYEVR('L','V','V', ... ) 77=  I  U U'  / ( n ulp ) DSYEVR('L','V','V', ... ) 78= D(with Z)  D(w/o Z) / (D ulp) DSYEVR('L','N','V', ... ) Tests 25 through 78 are repeated (as tests 79 through 132) with UPLO='U' To be added in 1999 79=  A  U S U'  / ( A n ulp ) DSPEVR('L','V','A', ... ) 80=  I  U U'  / ( n ulp ) DSPEVR('L','V','A', ... ) 81= D(with Z)  D(w/o Z) / (D ulp) DSPEVR('L','N','A', ... ) 82=  A  U S U'  / ( A n ulp ) DSPEVR('L','V','I', ... ) 83=  I  U U'  / ( n ulp ) DSPEVR('L','V','I', ... ) 84= D(with Z)  D(w/o Z) / (D ulp) DSPEVR('L','N','I', ... ) 85=  A  U S U'  / ( A n ulp ) DSPEVR('L','V','V', ... ) 86=  I  U U'  / ( n ulp ) DSPEVR('L','V','V', ... ) 87= D(with Z)  D(w/o Z) / (D ulp) DSPEVR('L','N','V', ... ) 88=  A  U S U'  / ( A n ulp ) DSBEVR('L','V','A', ... ) 89=  I  U U'  / ( n ulp ) DSBEVR('L','V','A', ... ) 90= D(with Z)  D(w/o Z) / (D ulp) DSBEVR('L','N','A', ... ) 91=  A  U S U'  / ( A n ulp ) DSBEVR('L','V','I', ... ) 92=  I  U U'  / ( n ulp ) DSBEVR('L','V','I', ... ) 93= D(with Z)  D(w/o Z) / (D ulp) DSBEVR('L','N','I', ... ) 94=  A  U S U'  / ( A n ulp ) DSBEVR('L','V','V', ... ) 95=  I  U U'  / ( n ulp ) DSBEVR('L','V','V', ... ) 96= D(with Z)  D(w/o Z) / (D ulp) DSBEVR('L','N','V', ... )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine ddrvsx (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NIUNIT, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( lda, * ) HT, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WRT, double precision, dimension( * ) WIT, double precision, dimension( * ) WRTMP, double precision, dimension( * ) WITMP, double precision, dimension( ldvs, * ) VS, integer LDVS, double precision, dimension( ldvs, * ) VS1, double precision, dimension( 17 ) RESULT, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, logical, dimension( * ) BWORK, integer INFO)
DDRVSX
Purpose:

DDRVSX checks the nonsymmetric eigenvalue (Schur form) problem expert driver DGEESX. DDRVSX uses both test matrices generated randomly depending on data supplied in the calling sequence, as well as on data read from an input file and including precomputed condition numbers to which it compares the ones it computes. When DDRVSX is called, a number of matrix "sizes" ("n's") and a number of matrix "types" are specified. For each size ("n") and each type of matrix, one matrix will be generated and used to test the nonsymmetric eigenroutines. For each matrix, 15 tests will be performed: (1) 0 if T is in Schur form, 1/ulp otherwise (no sorting of eigenvalues) (2)  A  VS T VS'  / ( n A ulp ) Here VS is the matrix of Schur eigenvectors, and T is in Schur form (no sorting of eigenvalues). (3)  I  VS VS'  / ( n ulp ) (no sorting of eigenvalues). (4) 0 if WR+sqrt(1)*WI are eigenvalues of T 1/ulp otherwise (no sorting of eigenvalues) (5) 0 if T(with VS) = T(without VS), 1/ulp otherwise (no sorting of eigenvalues) (6) 0 if eigenvalues(with VS) = eigenvalues(without VS), 1/ulp otherwise (no sorting of eigenvalues) (7) 0 if T is in Schur form, 1/ulp otherwise (with sorting of eigenvalues) (8)  A  VS T VS'  / ( n A ulp ) Here VS is the matrix of Schur eigenvectors, and T is in Schur form (with sorting of eigenvalues). (9)  I  VS VS'  / ( n ulp ) (with sorting of eigenvalues). (10) 0 if WR+sqrt(1)*WI are eigenvalues of T 1/ulp otherwise If workspace sufficient, also compare WR, WI with and without reciprocal condition numbers (with sorting of eigenvalues) (11) 0 if T(with VS) = T(without VS), 1/ulp otherwise If workspace sufficient, also compare T with and without reciprocal condition numbers (with sorting of eigenvalues) (12) 0 if eigenvalues(with VS) = eigenvalues(without VS), 1/ulp otherwise If workspace sufficient, also compare VS with and without reciprocal condition numbers (with sorting of eigenvalues) (13) if sorting worked and SDIM is the number of eigenvalues which were SELECTed If workspace sufficient, also compare SDIM with and without reciprocal condition numbers (14) if RCONDE the same no matter if VS and/or RCONDV computed (15) if RCONDV the same no matter if VS and/or RCONDE computed The "sizes" are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) The zero matrix. (2) The identity matrix. (3) A (transposed) Jordan block, with 1's on the diagonal. (4) A diagonal matrix with evenly spaced entries 1, ..., ULP and random signs. (ULP = (first number larger than 1)  1 ) (5) A diagonal matrix with geometrically spaced entries 1, ..., ULP and random signs. (6) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP and random signs. (7) Same as (4), but multiplied by a constant near the overflow threshold (8) Same as (4), but multiplied by a constant near the underflow threshold (9) A matrix of the form U' T U, where U is orthogonal and T has evenly spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (10) A matrix of the form U' T U, where U is orthogonal and T has geometrically spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (11) A matrix of the form U' T U, where U is orthogonal and T has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (12) A matrix of the form U' T U, where U is orthogonal and T has real or complex conjugate paired eigenvalues randomly chosen from ( ULP, 1 ) and random O(1) entries in the upper triangle. (13) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (14) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has geometrically spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (15) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (16) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has real or complex conjugate paired eigenvalues randomly chosen from ( ULP, 1 ) and random O(1) entries in the upper triangle. (17) Same as (16), but multiplied by a constant near the overflow threshold (18) Same as (16), but multiplied by a constant near the underflow threshold (19) Nonsymmetric matrix with random entries chosen from (1,1). If N is at least 4, all entries in first two rows and last row, and first column and last two columns are zero. (20) Same as (19), but multiplied by a constant near the overflow threshold (21) Same as (19), but multiplied by a constant near the underflow threshold In addition, an input file will be read from logical unit number NIUNIT. The file contains matrices along with precomputed eigenvalues and reciprocal condition numbers for the eigenvalue average and right invariant subspace. For these matrices, in addition to tests (1) to (15) we will compute the following two tests: (16) RCONDE  RCDEIN / cond(RCONDE) RCONDE is the reciprocal average eigenvalue condition number computed by DGEESX and RCDEIN (the precomputed true value) is supplied as input. cond(RCONDE) is the condition number of RCONDE, and takes errors in computing RCONDE into account, so that the resulting quantity should be O(ULP). cond(RCONDE) is essentially given by norm(A)/RCONDV. (17) RCONDV  RCDVIN / cond(RCONDV) RCONDV is the reciprocal right invariant subspace condition number computed by DGEESX and RCDVIN (the precomputed true value) is supplied as input. cond(RCONDV) is the condition number of RCONDV, and takes errors in computing RCONDV into account, so that the resulting quantity should be O(ULP). cond(RCONDV) is essentially given by norm(A)/RCONDE.
Parameters:

NSIZES
NSIZES is INTEGER The number of sizes of matrices to use. NSIZES must be at least zero. If it is zero, no randomly generated matrices are tested, but any test matrices read from NIUNIT will be tested.
NNNN is INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. The values must be at least zero.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. NTYPES must be at least zero. If it is zero, no randomly generated test matrices are tested, but and test matrices read from NIUNIT will be tested. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DDRVSX to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
NIUNITNIUNIT is INTEGER The FORTRAN unit number for reading in the data file of problems to solve.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns INFO not equal to 0.)
AA is DOUBLE PRECISION array, dimension (LDA, max(NN)) Used to hold the matrix whose eigenvalues are to be computed. On exit, A contains the last matrix actually used.
LDALDA is INTEGER The leading dimension of A, and H. LDA must be at least 1 and at least max( NN ).
HH is DOUBLE PRECISION array, dimension (LDA, max(NN)) Another copy of the test matrix A, modified by DGEESX.
HTHT is DOUBLE PRECISION array, dimension (LDA, max(NN)) Yet another copy of the test matrix A, modified by DGEESX.
WRWR is DOUBLE PRECISION array, dimension (max(NN))
WIWI is DOUBLE PRECISION array, dimension (max(NN)) The real and imaginary parts of the eigenvalues of A. On exit, WR + WI*i are the eigenvalues of the matrix in A.
WRTWRT is DOUBLE PRECISION array, dimension (max(NN))
WITWIT is DOUBLE PRECISION array, dimension (max(NN)) Like WR, WI, these arrays contain the eigenvalues of A, but those computed when DGEESX only computes a partial eigendecomposition, i.e. not Schur vectors
WRTMPWRTMP is DOUBLE PRECISION array, dimension (max(NN))
WITMPWITMP is DOUBLE PRECISION array, dimension (max(NN)) More temporary storage for eigenvalues.
VSVS is DOUBLE PRECISION array, dimension (LDVS, max(NN)) VS holds the computed Schur vectors.
LDVSLDVS is INTEGER Leading dimension of VS. Must be at least max(1,max(NN)).
VS1VS1 is DOUBLE PRECISION array, dimension (LDVS, max(NN)) VS1 holds another copy of the computed Schur vectors.
RESULTRESULT is DOUBLE PRECISION array, dimension (17) The values computed by the 17 tests described above. The values are currently limited to 1/ulp, to avoid overflow.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The number of entries in WORK. This must be at least max(3*NN(j),2*NN(j)**2) for all j.
IWORKIWORK is INTEGER array, dimension (max(NN)*max(NN))
BWORKBWORK is LOGICAL array, dimension (max(NN))
INFOINFO is INTEGER If 0, successful exit. <0, input parameter INFO is incorrect >0, DLATMR, SLATMS, SLATME or DGET24 returned an error code and INFO is its absolute value  Some Local Variables and Parameters:      ZERO, ONE Real 0 and 1. MAXTYP The number of types defined. NMAX Largest value in NN. NERRS The number of tests which have exceeded THRESH COND, CONDS, IMODE Values to be passed to the matrix generators. ANORM Norm of A; passed to matrix generators. OVFL, UNFL Overflow and underflow thresholds. ULP, ULPINV Finest relative precision and its inverse. RTULP, RTULPI Square roots of the previous 4 values. The following four arrays decode JTYPE: KTYPE(j) The general type (110) for type "j". KMODE(j) The MODE value to be passed to the matrix generator for type "j". KMAGN(j) The order of magnitude ( O(1), O(overflow^(1/2) ), O(underflow^(1/2) ) KCONDS(j) Selectw whether CONDS is to be 1 or 1/sqrt(ulp). (0 means irrelevant.)
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine ddrvvx (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NIUNIT, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WR1, double precision, dimension( * ) WI1, double precision, dimension( ldvl, * ) VL, integer LDVL, double precision, dimension( ldvr, * ) VR, integer LDVR, double precision, dimension( ldlre, * ) LRE, integer LDLRE, double precision, dimension( * ) RCONDV, double precision, dimension( * ) RCNDV1, double precision, dimension( * ) RCDVIN, double precision, dimension( * ) RCONDE, double precision, dimension( * ) RCNDE1, double precision, dimension( * ) RCDEIN, double precision, dimension( * ) SCALE, double precision, dimension( * ) SCALE1, double precision, dimension( 11 ) RESULT, double precision, dimension( * ) WORK, integer NWORK, integer, dimension( * ) IWORK, integer INFO)
DDRVVX
Purpose:

DDRVVX checks the nonsymmetric eigenvalue problem expert driver DGEEVX. DDRVVX uses both test matrices generated randomly depending on data supplied in the calling sequence, as well as on data read from an input file and including precomputed condition numbers to which it compares the ones it computes. When DDRVVX is called, a number of matrix "sizes" ("n's") and a number of matrix "types" are specified in the calling sequence. For each size ("n") and each type of matrix, one matrix will be generated and used to test the nonsymmetric eigenroutines. For each matrix, 9 tests will be performed: (1)  A * VR  VR * W  / ( n A ulp ) Here VR is the matrix of unit right eigenvectors. W is a block diagonal matrix, with a 1x1 block for each real eigenvalue and a 2x2 block for each complex conjugate pair. If eigenvalues j and j+1 are a complex conjugate pair, so WR(j) = WR(j+1) = wr and WI(j) =  WI(j+1) = wi, then the 2 x 2 block corresponding to the pair will be: ( wr wi ) ( wi wr ) Such a block multiplying an n x 2 matrix ( ur ui ) on the right will be the same as multiplying ur + i*ui by wr + i*wi. (2)  A**H * VL  VL * W**H  / ( n A ulp ) Here VL is the matrix of unit left eigenvectors, A**H is the conjugate transpose of A, and W is as above. (3)  VR(i)  1  / ulp and largest component real VR(i) denotes the ith column of VR. (4)  VL(i)  1  / ulp and largest component real VL(i) denotes the ith column of VL. (5) W(full) = W(partial) W(full) denotes the eigenvalues computed when VR, VL, RCONDV and RCONDE are also computed, and W(partial) denotes the eigenvalues computed when only some of VR, VL, RCONDV, and RCONDE are computed. (6) VR(full) = VR(partial) VR(full) denotes the right eigenvectors computed when VL, RCONDV and RCONDE are computed, and VR(partial) denotes the result when only some of VL and RCONDV are computed. (7) VL(full) = VL(partial) VL(full) denotes the left eigenvectors computed when VR, RCONDV and RCONDE are computed, and VL(partial) denotes the result when only some of VR and RCONDV are computed. (8) 0 if SCALE, ILO, IHI, ABNRM (full) = SCALE, ILO, IHI, ABNRM (partial) 1/ulp otherwise SCALE, ILO, IHI and ABNRM describe how the matrix is balanced. (full) is when VR, VL, RCONDE and RCONDV are also computed, and (partial) is when some are not computed. (9) RCONDV(full) = RCONDV(partial) RCONDV(full) denotes the reciprocal condition numbers of the right eigenvectors computed when VR, VL and RCONDE are also computed. RCONDV(partial) denotes the reciprocal condition numbers when only some of VR, VL and RCONDE are computed. The "sizes" are specified by an array NN(1:NSIZES); the value of each element NN(j) specifies one size. The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if DOTYPE(j) is .TRUE., then matrix type "j" will be generated. Currently, the list of possible types is: (1) The zero matrix. (2) The identity matrix. (3) A (transposed) Jordan block, with 1's on the diagonal. (4) A diagonal matrix with evenly spaced entries 1, ..., ULP and random signs. (ULP = (first number larger than 1)  1 ) (5) A diagonal matrix with geometrically spaced entries 1, ..., ULP and random signs. (6) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP and random signs. (7) Same as (4), but multiplied by a constant near the overflow threshold (8) Same as (4), but multiplied by a constant near the underflow threshold (9) A matrix of the form U' T U, where U is orthogonal and T has evenly spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (10) A matrix of the form U' T U, where U is orthogonal and T has geometrically spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (11) A matrix of the form U' T U, where U is orthogonal and T has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (12) A matrix of the form U' T U, where U is orthogonal and T has real or complex conjugate paired eigenvalues randomly chosen from ( ULP, 1 ) and random O(1) entries in the upper triangle. (13) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (14) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has geometrically spaced entries 1, ..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (15) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP with random signs on the diagonal and random O(1) entries in the upper triangle. (16) A matrix of the form X' T X, where X has condition SQRT( ULP ) and T has real or complex conjugate paired eigenvalues randomly chosen from ( ULP, 1 ) and random O(1) entries in the upper triangle. (17) Same as (16), but multiplied by a constant near the overflow threshold (18) Same as (16), but multiplied by a constant near the underflow threshold (19) Nonsymmetric matrix with random entries chosen from (1,1). If N is at least 4, all entries in first two rows and last row, and first column and last two columns are zero. (20) Same as (19), but multiplied by a constant near the overflow threshold (21) Same as (19), but multiplied by a constant near the underflow threshold In addition, an input file will be read from logical unit number NIUNIT. The file contains matrices along with precomputed eigenvalues and reciprocal condition numbers for the eigenvalues and right eigenvectors. For these matrices, in addition to tests (1) to (9) we will compute the following two tests: (10) RCONDV  RCDVIN / cond(RCONDV) RCONDV is the reciprocal right eigenvector condition number computed by DGEEVX and RCDVIN (the precomputed true value) is supplied as input. cond(RCONDV) is the condition number of RCONDV, and takes errors in computing RCONDV into account, so that the resulting quantity should be O(ULP). cond(RCONDV) is essentially given by norm(A)/RCONDE. (11) RCONDE  RCDEIN / cond(RCONDE) RCONDE is the reciprocal eigenvalue condition number computed by DGEEVX and RCDEIN (the precomputed true value) is supplied as input. cond(RCONDE) is the condition number of RCONDE, and takes errors in computing RCONDE into account, so that the resulting quantity should be O(ULP). cond(RCONDE) is essentially given by norm(A)/RCONDV.
Parameters:

NSIZES
NSIZES is INTEGER The number of sizes of matrices to use. NSIZES must be at least zero. If it is zero, no randomly generated matrices are tested, but any test matrices read from NIUNIT will be tested.
NNNN is INTEGER array, dimension (NSIZES) An array containing the sizes to be used for the matrices. Zero values will be skipped. The values must be at least zero.
NTYPESNTYPES is INTEGER The number of elements in DOTYPE. NTYPES must be at least zero. If it is zero, no randomly generated test matrices are tested, but and test matrices read from NIUNIT will be tested. If it is MAXTYP+1 and NSIZES is 1, then an additional type, MAXTYP+1 is defined, which is to use whatever matrix is in A. This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .
DOTYPEDOTYPE is LOGICAL array, dimension (NTYPES) If DOTYPE(j) is .TRUE., then for each size in NN a matrix of that size and of type j will be generated. If NTYPES is smaller than the maximum number of types defined (PARAMETER MAXTYP), then types NTYPES+1 through MAXTYP will not be generated. If NTYPES is larger than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES) will be ignored.
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The array elements should be between 0 and 4095; if not they will be reduced mod 4096. Also, ISEED(4) must be odd. The random number generator uses a linear congruential sequence limited to small integers, and so should produce machine independent random numbers. The values of ISEED are changed on exit, and can be used in the next call to DDRVVX to continue the same random number sequence.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
NIUNITNIUNIT is INTEGER The FORTRAN unit number for reading in the data file of problems to solve.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns INFO not equal to 0.)
AA is DOUBLE PRECISION array, dimension (LDA, max(NN,12)) Used to hold the matrix whose eigenvalues are to be computed. On exit, A contains the last matrix actually used.
LDALDA is INTEGER The leading dimension of the arrays A and H. LDA >= max(NN,12), since 12 is the dimension of the largest matrix in the precomputed input file.
HH is DOUBLE PRECISION array, dimension (LDA, max(NN,12)) Another copy of the test matrix A, modified by DGEEVX.
WRWR is DOUBLE PRECISION array, dimension (max(NN))
WIWI is DOUBLE PRECISION array, dimension (max(NN)) The real and imaginary parts of the eigenvalues of A. On exit, WR + WI*i are the eigenvalues of the matrix in A.
WR1WR1 is DOUBLE PRECISION array, dimension (max(NN,12))
WI1WI1 is DOUBLE PRECISION array, dimension (max(NN,12)) Like WR, WI, these arrays contain the eigenvalues of A, but those computed when DGEEVX only computes a partial eigendecomposition, i.e. not the eigenvalues and left and right eigenvectors.
VLVL is DOUBLE PRECISION array, dimension (LDVL, max(NN,12)) VL holds the computed left eigenvectors.
LDVLLDVL is INTEGER Leading dimension of VL. Must be at least max(1,max(NN,12)).
VRVR is DOUBLE PRECISION array, dimension (LDVR, max(NN,12)) VR holds the computed right eigenvectors.
LDVRLDVR is INTEGER Leading dimension of VR. Must be at least max(1,max(NN,12)).
LRELRE is DOUBLE PRECISION array, dimension (LDLRE, max(NN,12)) LRE holds the computed right or left eigenvectors.
LDLRELDLRE is INTEGER Leading dimension of LRE. Must be at least max(1,max(NN,12))
RCONDVRCONDV is DOUBLE PRECISION array, dimension (N) RCONDV holds the computed reciprocal condition numbers for eigenvectors.
RCNDV1RCNDV1 is DOUBLE PRECISION array, dimension (N) RCNDV1 holds more computed reciprocal condition numbers for eigenvectors.
RCDVINRCDVIN is DOUBLE PRECISION array, dimension (N) When COMP = .TRUE. RCDVIN holds the precomputed reciprocal condition numbers for eigenvectors to be compared with RCONDV.
RCONDERCONDE is DOUBLE PRECISION array, dimension (N) RCONDE holds the computed reciprocal condition numbers for eigenvalues.
RCNDE1RCNDE1 is DOUBLE PRECISION array, dimension (N) RCNDE1 holds more computed reciprocal condition numbers for eigenvalues.
RCDEINRCDEIN is DOUBLE PRECISION array, dimension (N) When COMP = .TRUE. RCDEIN holds the precomputed reciprocal condition numbers for eigenvalues to be compared with RCONDE.
SCALESCALE is DOUBLE PRECISION array, dimension (N) Holds information describing balancing of matrix.
SCALE1SCALE1 is DOUBLE PRECISION array, dimension (N) Holds information describing balancing of matrix.
RESULTRESULT is DOUBLE PRECISION array, dimension (11) The values computed by the seven tests described above. The values are currently limited to 1/ulp, to avoid overflow.
WORKWORK is DOUBLE PRECISION array, dimension (NWORK)
NWORKNWORK is INTEGER The number of entries in WORK. This must be at least max(6*12+2*12**2,6*NN(j)+2*NN(j)**2) = max( 360 ,6*NN(j)+2*NN(j)**2) for all j.
IWORKIWORK is INTEGER array, dimension (2*max(NN,12))
INFOINFO is INTEGER If 0, then successful exit. If <0, then input parameter INFO is incorrect. If >0, DLATMR, SLATMS, SLATME or DGET23 returned an error code, and INFO is its absolute value.  Some Local Variables and Parameters:      ZERO, ONE Real 0 and 1. MAXTYP The number of types defined. NMAX Largest value in NN or 12. NERRS The number of tests which have exceeded THRESH COND, CONDS, IMODE Values to be passed to the matrix generators. ANORM Norm of A; passed to matrix generators. OVFL, UNFL Overflow and underflow thresholds. ULP, ULPINV Finest relative precision and its inverse. RTULP, RTULPI Square roots of the previous 4 values. The following four arrays decode JTYPE: KTYPE(j) The general type (110) for type "j". KMODE(j) The MODE value to be passed to the matrix generator for type "j". KMAGN(j) The order of magnitude ( O(1), O(overflow^(1/2) ), O(underflow^(1/2) ) KCONDS(j) Selectw whether CONDS is to be 1 or 1/sqrt(ulp). (0 means irrelevant.)
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine derrbd (character*3 PATH, integer NUNIT)
DERRBD
Purpose:

DERRBD tests the error exits for DGEBD2, DGEBRD, DORGBR, DORMBR, DBDSQR, DBDSDC and DBDSVDX.
Parameters:

PATH
PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
NUNITNUNIT is INTEGER The unit number for output.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine derrec (character*3 PATH, integer NUNIT)
DERREC
Purpose:

DERREC tests the error exits for the routines for eigen condition estimation for DOUBLE PRECISION matrices: DTRSYL, STREXC, STRSNA and STRSEN.
Parameters:

PATH
PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
NUNITNUNIT 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 derred (character*3 PATH, integer NUNIT)
DERRED
Purpose:

DERRED tests the error exits for the eigenvalue driver routines for DOUBLE PRECISION matrices: PATH driver description    SEV DGEEV find eigenvalues/eigenvectors for nonsymmetric A SES DGEES find eigenvalues/Schur form for nonsymmetric A SVX DGEEVX SGEEV + balancing and condition estimation SSX DGEESX SGEES + balancing and condition estimation DBD DGESVD compute SVD of an MbyN matrix A DGESDD compute SVD of an MbyN matrix A (by divide and conquer) DGEJSV compute SVD of an MbyN matrix A where M >= N DGESVDX compute SVD of an MbyN matrix A(by bisection and inverse iteration)
Parameters:

PATH
PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
NUNITNUNIT is INTEGER The unit number for output.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine derrgg (character*3 PATH, integer NUNIT)
DERRGG
Purpose:

DERRGG tests the error exits for DGGES, DGGESX, DGGEV, DGGEVX, DGGGLM, DGGHRD, DGGLSE, DGGQRF, DGGRQF, DGGSVD3, DGGSVP3, DHGEQZ, DORCSD, DTGEVC, DTGEXC, DTGSEN, DTGSJA, DTGSNA, DGGES3, DGGEV3, and DTGSYL.
Parameters:

PATH
PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
NUNITNUNIT is INTEGER The unit number for output.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine derrhs (character*3 PATH, integer NUNIT)
DERRHS
Purpose:

DERRHS tests the error exits for DGEBAK, SGEBAL, SGEHRD, DORGHR, DORMHR, DHSEQR, SHSEIN, and DTREVC.
Parameters:

PATH
PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
NUNITNUNIT 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 derrst (character*3 PATH, integer NUNIT)
DERRST
Purpose:

DERRST tests the error exits for DSYTRD, DORGTR, DORMTR, DSPTRD, DOPGTR, DOPMTR, DSTEQR, SSTERF, SSTEBZ, SSTEIN, DPTEQR, DSBTRD, DSYEV, SSYEVX, SSYEVD, DSBEV, SSBEVX, SSBEVD, DSPEV, SSPEVX, SSPEVD, DSTEV, SSTEVX, SSTEVD, and SSTEDC.
Parameters:

PATH
PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
NUNITNUNIT 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 dget02 (character TRANS, integer M, integer N, integer NRHS, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldx, * ) X, integer LDX, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)
DGET02
Purpose:

DGET02 computes the residual for a solution of a system of linear equations A*x = b or A'*x = b: RESID = norm(B  A*X) / ( norm(A) * norm(X) * EPS ), where EPS is the machine epsilon.
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
MM is INTEGER The number of rows of the matrix A. M >= 0.
NN is INTEGER The number of columns of the matrix A. N >= 0.
NRHSNRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0.
AA is DOUBLE PRECISION array, dimension (LDA,N) The original M x N matrix A.
LDALDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).
XX is DOUBLE PRECISION array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations.
LDXLDX 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).
BB is DOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B  A*X.
LDBLDB 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).
RWORKRWORK is DOUBLE PRECISION array, dimension (M)
RESIDRESID is DOUBLE PRECISION 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 dget10 (integer M, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) WORK, double precision RESULT)
DGET10
Purpose:

DGET10 compares two matrices A and B and computes the ratio RESULT = norm( A  B ) / ( norm(A) * M * EPS )
Parameters:

M
M is INTEGER The number of rows of the matrices A and B.
NN is INTEGER The number of columns of the matrices A and B.
AA is DOUBLE PRECISION array, dimension (LDA,N) The m by n matrix A.
LDALDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).
BB is DOUBLE PRECISION array, dimension (LDB,N) The m by n matrix B.
LDBLDB is INTEGER The leading dimension of the array B. LDB >= max(1,M).
WORKWORK is DOUBLE PRECISION array, dimension (M)
RESULTRESULT is DOUBLE PRECISION RESULT = norm( A  B ) / ( norm(A) * M * EPS )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget22 (character TRANSA, character TRANSE, character TRANSW, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lde, * ) E, integer LDE, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)
DGET22
Purpose:

DGET22 does an eigenvector check. The basic test is: RESULT(1) =  A E  E W  / ( A E ulp ) using the 1norm. It also tests the normalization of E: RESULT(2) = max  mnorm(E(j))  1  / ( n ulp ) j where E(j) is the jth eigenvector, and mnorm is the maxnorm of a vector. If an eigenvector is complex, as determined from WI(j) nonzero, then the maxnorm of the vector ( er + i*ei ) is the maximum of er(1) + ei(1), ... , er(n) + ei(n) W is a block diagonal matrix, with a 1 by 1 block for each real eigenvalue and a 2 by 2 block for each complex conjugate pair. If eigenvalues j and j+1 are a complex conjugate pair, so that WR(j) = WR(j+1) = wr and WI(j) =  WI(j+1) = wi, then the 2 by 2 block corresponding to the pair will be: ( wr wi ) ( wi wr ) Such a block multiplying an n by 2 matrix ( ur ui ) on the right will be the same as multiplying ur + i*ui by wr + i*wi. To handle various schemes for storage of left eigenvectors, there are options to use Atranspose instead of A, Etranspose instead of E, and/or Wtranspose instead of W.
Parameters:

TRANSA
TRANSA is CHARACTER*1 Specifies whether or not A is transposed. = 'N': No transpose = 'T': Transpose = 'C': Conjugate transpose (= Transpose)
TRANSETRANSE is CHARACTER*1 Specifies whether or not E is transposed. = 'N': No transpose, eigenvectors are in columns of E = 'T': Transpose, eigenvectors are in rows of E = 'C': Conjugate transpose (= Transpose)
TRANSWTRANSW is CHARACTER*1 Specifies whether or not W is transposed. = 'N': No transpose = 'T': Transpose, use WI(j) instead of WI(j) = 'C': Conjugate transpose, use WI(j) instead of WI(j)
NN is INTEGER The order of the matrix A. N >= 0.
AA is DOUBLE PRECISION array, dimension (LDA,N) The matrix whose eigenvectors are in E.
LDALDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
EE is DOUBLE PRECISION array, dimension (LDE,N) The matrix of eigenvectors. If TRANSE = 'N', the eigenvectors are stored in the columns of E, if TRANSE = 'T' or 'C', the eigenvectors are stored in the rows of E.
LDELDE is INTEGER The leading dimension of the array E. LDE >= max(1,N).
WRWR is DOUBLE PRECISION array, dimension (N)
WIWI is DOUBLE PRECISION array, dimension (N) The real and imaginary parts of the eigenvalues of A. Purely real eigenvalues are indicated by WI(j) = 0. Complex conjugate pairs are indicated by WR(j)=WR(j+1) and WI(j) =  WI(j+1) nonzero; the real part is assumed to be stored in the jth row/column and the imaginary part in the (j+1)th row/column.
WORKWORK is DOUBLE PRECISION array, dimension (N*(N+1))
RESULTRESULT is DOUBLE PRECISION array, dimension (2) RESULT(1) =  A E  E W  / ( A E ulp ) RESULT(2) = max  mnorm(E(j))  1  / ( n ulp )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget23 (logical COMP, character BALANC, integer JTYPE, double precision THRESH, integer, dimension( 4 ) ISEED, integer NOUNIT, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WR1, double precision, dimension( * ) WI1, double precision, dimension( ldvl, * ) VL, integer LDVL, double precision, dimension( ldvr, * ) VR, integer LDVR, double precision, dimension( ldlre, * ) LRE, integer LDLRE, double precision, dimension( * ) RCONDV, double precision, dimension( * ) RCNDV1, double precision, dimension( * ) RCDVIN, double precision, dimension( * ) RCONDE, double precision, dimension( * ) RCNDE1, double precision, dimension( * ) RCDEIN, double precision, dimension( * ) SCALE, double precision, dimension( * ) SCALE1, double precision, dimension( 11 ) RESULT, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer INFO)
DGET23
Purpose:

DGET23 checks the nonsymmetric eigenvalue problem driver SGEEVX. If COMP = .FALSE., the first 8 of the following tests will be performed on the input matrix A, and also test 9 if LWORK is sufficiently large. if COMP is .TRUE. all 11 tests will be performed. (1)  A * VR  VR * W  / ( n A ulp ) Here VR is the matrix of unit right eigenvectors. W is a block diagonal matrix, with a 1x1 block for each real eigenvalue and a 2x2 block for each complex conjugate pair. If eigenvalues j and j+1 are a complex conjugate pair, so WR(j) = WR(j+1) = wr and WI(j) =  WI(j+1) = wi, then the 2 x 2 block corresponding to the pair will be: ( wr wi ) ( wi wr ) Such a block multiplying an n x 2 matrix ( ur ui ) on the right will be the same as multiplying ur + i*ui by wr + i*wi. (2)  A**H * VL  VL * W**H  / ( n A ulp ) Here VL is the matrix of unit left eigenvectors, A**H is the conjugate transpose of A, and W is as above. (3)  VR(i)  1  / ulp and largest component real VR(i) denotes the ith column of VR. (4)  VL(i)  1  / ulp and largest component real VL(i) denotes the ith column of VL. (5) 0 if W(full) = W(partial), 1/ulp otherwise W(full) denotes the eigenvalues computed when VR, VL, RCONDV and RCONDE are also computed, and W(partial) denotes the eigenvalues computed when only some of VR, VL, RCONDV, and RCONDE are computed. (6) 0 if VR(full) = VR(partial), 1/ulp otherwise VR(full) denotes the right eigenvectors computed when VL, RCONDV and RCONDE are computed, and VR(partial) denotes the result when only some of VL and RCONDV are computed. (7) 0 if VL(full) = VL(partial), 1/ulp otherwise VL(full) denotes the left eigenvectors computed when VR, RCONDV and RCONDE are computed, and VL(partial) denotes the result when only some of VR and RCONDV are computed. (8) 0 if SCALE, ILO, IHI, ABNRM (full) = SCALE, ILO, IHI, ABNRM (partial) 1/ulp otherwise SCALE, ILO, IHI and ABNRM describe how the matrix is balanced. (full) is when VR, VL, RCONDE and RCONDV are also computed, and (partial) is when some are not computed. (9) 0 if RCONDV(full) = RCONDV(partial), 1/ulp otherwise RCONDV(full) denotes the reciprocal condition numbers of the right eigenvectors computed when VR, VL and RCONDE are also computed. RCONDV(partial) denotes the reciprocal condition numbers when only some of VR, VL and RCONDE are computed. (10) RCONDV  RCDVIN / cond(RCONDV) RCONDV is the reciprocal right eigenvector condition number computed by DGEEVX and RCDVIN (the precomputed true value) is supplied as input. cond(RCONDV) is the condition number of RCONDV, and takes errors in computing RCONDV into account, so that the resulting quantity should be O(ULP). cond(RCONDV) is essentially given by norm(A)/RCONDE. (11) RCONDE  RCDEIN / cond(RCONDE) RCONDE is the reciprocal eigenvalue condition number computed by DGEEVX and RCDEIN (the precomputed true value) is supplied as input. cond(RCONDE) is the condition number of RCONDE, and takes errors in computing RCONDE into account, so that the resulting quantity should be O(ULP). cond(RCONDE) is essentially given by norm(A)/RCONDV.
Parameters:

COMP
COMP is LOGICAL COMP describes which input tests to perform: = .FALSE. if the computed condition numbers are not to be tested against RCDVIN and RCDEIN = .TRUE. if they are to be compared
BALANCBALANC is CHARACTER Describes the balancing option to be tested. = 'N' for no permuting or diagonal scaling = 'P' for permuting but no diagonal scaling = 'S' for no permuting but diagonal scaling = 'B' for permuting and diagonal scaling
JTYPEJTYPE is INTEGER Type of input matrix. Used to label output if error occurs.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
ISEEDISEED is INTEGER array, dimension (4) If COMP = .FALSE., the random number generator seed used to produce matrix. If COMP = .TRUE., ISEED(1) = the number of the example. Used to label output if error occurs.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns INFO not equal to 0.)
NN is INTEGER The dimension of A. N must be at least 0.
AA is DOUBLE PRECISION array, dimension (LDA,N) Used to hold the matrix whose eigenvalues are to be computed.
LDALDA is INTEGER The leading dimension of A, and H. LDA must be at least 1 and at least N.
HH is DOUBLE PRECISION array, dimension (LDA,N) Another copy of the test matrix A, modified by DGEEVX.
WRWR is DOUBLE PRECISION array, dimension (N)
WIWI is DOUBLE PRECISION array, dimension (N) The real and imaginary parts of the eigenvalues of A. On exit, WR + WI*i are the eigenvalues of the matrix in A.
WR1WR1 is DOUBLE PRECISION array, dimension (N)
WI1WI1 is DOUBLE PRECISION array, dimension (N) Like WR, WI, these arrays contain the eigenvalues of A, but those computed when DGEEVX only computes a partial eigendecomposition, i.e. not the eigenvalues and left and right eigenvectors.
VLVL is DOUBLE PRECISION array, dimension (LDVL,N) VL holds the computed left eigenvectors.
LDVLLDVL is INTEGER Leading dimension of VL. Must be at least max(1,N).
VRVR is DOUBLE PRECISION array, dimension (LDVR,N) VR holds the computed right eigenvectors.
LDVRLDVR is INTEGER Leading dimension of VR. Must be at least max(1,N).
LRELRE is DOUBLE PRECISION array, dimension (LDLRE,N) LRE holds the computed right or left eigenvectors.
LDLRELDLRE is INTEGER Leading dimension of LRE. Must be at least max(1,N).
RCONDVRCONDV is DOUBLE PRECISION array, dimension (N) RCONDV holds the computed reciprocal condition numbers for eigenvectors.
RCNDV1RCNDV1 is DOUBLE PRECISION array, dimension (N) RCNDV1 holds more computed reciprocal condition numbers for eigenvectors.
RCDVINRCDVIN is DOUBLE PRECISION array, dimension (N) When COMP = .TRUE. RCDVIN holds the precomputed reciprocal condition numbers for eigenvectors to be compared with RCONDV.
RCONDERCONDE is DOUBLE PRECISION array, dimension (N) RCONDE holds the computed reciprocal condition numbers for eigenvalues.
RCNDE1RCNDE1 is DOUBLE PRECISION array, dimension (N) RCNDE1 holds more computed reciprocal condition numbers for eigenvalues.
RCDEINRCDEIN is DOUBLE PRECISION array, dimension (N) When COMP = .TRUE. RCDEIN holds the precomputed reciprocal condition numbers for eigenvalues to be compared with RCONDE.
SCALESCALE is DOUBLE PRECISION array, dimension (N) Holds information describing balancing of matrix.
SCALE1SCALE1 is DOUBLE PRECISION array, dimension (N) Holds information describing balancing of matrix.
RESULTRESULT is DOUBLE PRECISION array, dimension (11) The values computed by the 11 tests described above. The values are currently limited to 1/ulp, to avoid overflow.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The number of entries in WORK. This must be at least 3*N, and 6*N+N**2 if tests 9, 10 or 11 are to be performed.
IWORKIWORK is INTEGER array, dimension (2*N)
INFOINFO is INTEGER If 0, successful exit. If <0, input parameter INFO had an incorrect value. If >0, DGEEVX returned an error code, the absolute value of which is returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget24 (logical COMP, integer JTYPE, double precision THRESH, integer, dimension( 4 ) ISEED, integer NOUNIT, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( lda, * ) HT, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WRT, double precision, dimension( * ) WIT, double precision, dimension( * ) WRTMP, double precision, dimension( * ) WITMP, double precision, dimension( ldvs, * ) VS, integer LDVS, double precision, dimension( ldvs, * ) VS1, double precision RCDEIN, double precision RCDVIN, integer NSLCT, integer, dimension( * ) ISLCT, double precision, dimension( 17 ) RESULT, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, logical, dimension( * ) BWORK, integer INFO)
DGET24
Purpose:

DGET24 checks the nonsymmetric eigenvalue (Schur form) problem expert driver DGEESX. If COMP = .FALSE., the first 13 of the following tests will be be performed on the input matrix A, and also tests 14 and 15 if LWORK is sufficiently large. If COMP = .TRUE., all 17 test will be performed. (1) 0 if T is in Schur form, 1/ulp otherwise (no sorting of eigenvalues) (2)  A  VS T VS'  / ( n A ulp ) Here VS is the matrix of Schur eigenvectors, and T is in Schur form (no sorting of eigenvalues). (3)  I  VS VS'  / ( n ulp ) (no sorting of eigenvalues). (4) 0 if WR+sqrt(1)*WI are eigenvalues of T 1/ulp otherwise (no sorting of eigenvalues) (5) 0 if T(with VS) = T(without VS), 1/ulp otherwise (no sorting of eigenvalues) (6) 0 if eigenvalues(with VS) = eigenvalues(without VS), 1/ulp otherwise (no sorting of eigenvalues) (7) 0 if T is in Schur form, 1/ulp otherwise (with sorting of eigenvalues) (8)  A  VS T VS'  / ( n A ulp ) Here VS is the matrix of Schur eigenvectors, and T is in Schur form (with sorting of eigenvalues). (9)  I  VS VS'  / ( n ulp ) (with sorting of eigenvalues). (10) 0 if WR+sqrt(1)*WI are eigenvalues of T 1/ulp otherwise If workspace sufficient, also compare WR, WI with and without reciprocal condition numbers (with sorting of eigenvalues) (11) 0 if T(with VS) = T(without VS), 1/ulp otherwise If workspace sufficient, also compare T with and without reciprocal condition numbers (with sorting of eigenvalues) (12) 0 if eigenvalues(with VS) = eigenvalues(without VS), 1/ulp otherwise If workspace sufficient, also compare VS with and without reciprocal condition numbers (with sorting of eigenvalues) (13) if sorting worked and SDIM is the number of eigenvalues which were SELECTed If workspace sufficient, also compare SDIM with and without reciprocal condition numbers (14) if RCONDE the same no matter if VS and/or RCONDV computed (15) if RCONDV the same no matter if VS and/or RCONDE computed (16) RCONDE  RCDEIN / cond(RCONDE) RCONDE is the reciprocal average eigenvalue condition number computed by DGEESX and RCDEIN (the precomputed true value) is supplied as input. cond(RCONDE) is the condition number of RCONDE, and takes errors in computing RCONDE into account, so that the resulting quantity should be O(ULP). cond(RCONDE) is essentially given by norm(A)/RCONDV. (17) RCONDV  RCDVIN / cond(RCONDV) RCONDV is the reciprocal right invariant subspace condition number computed by DGEESX and RCDVIN (the precomputed true value) is supplied as input. cond(RCONDV) is the condition number of RCONDV, and takes errors in computing RCONDV into account, so that the resulting quantity should be O(ULP). cond(RCONDV) is essentially given by norm(A)/RCONDE.
Parameters:

COMP
COMP is LOGICAL COMP describes which input tests to perform: = .FALSE. if the computed condition numbers are not to be tested against RCDVIN and RCDEIN = .TRUE. if they are to be compared
JTYPEJTYPE is INTEGER Type of input matrix. Used to label output if error occurs.
ISEEDISEED is INTEGER array, dimension (4) If COMP = .FALSE., the random number generator seed used to produce matrix. If COMP = .TRUE., ISEED(1) = the number of the example. Used to label output if error occurs.
THRESHTHRESH is DOUBLE PRECISION A test will count as "failed" if the "error", computed as described above, exceeds THRESH. Note that the error is scaled to be O(1), so THRESH should be a reasonably small multiple of 1, e.g., 10 or 100. In particular, it should not depend on the precision (single vs. double) or the size of the matrix. It must be at least zero.
NOUNITNOUNIT is INTEGER The FORTRAN unit number for printing out error messages (e.g., if a routine returns INFO not equal to 0.)
NN is INTEGER The dimension of A. N must be at least 0.
AA is DOUBLE PRECISION array, dimension (LDA, N) Used to hold the matrix whose eigenvalues are to be computed.
LDALDA is INTEGER The leading dimension of A, and H. LDA must be at least 1 and at least N.
HH is DOUBLE PRECISION array, dimension (LDA, N) Another copy of the test matrix A, modified by DGEESX.
HTHT is DOUBLE PRECISION array, dimension (LDA, N) Yet another copy of the test matrix A, modified by DGEESX.
WRWR is DOUBLE PRECISION array, dimension (N)
WIWI is DOUBLE PRECISION array, dimension (N) The real and imaginary parts of the eigenvalues of A. On exit, WR + WI*i are the eigenvalues of the matrix in A.
WRTWRT is DOUBLE PRECISION array, dimension (N)
WITWIT is DOUBLE PRECISION array, dimension (N) Like WR, WI, these arrays contain the eigenvalues of A, but those computed when DGEESX only computes a partial eigendecomposition, i.e. not Schur vectors
WRTMPWRTMP is DOUBLE PRECISION array, dimension (N)
WITMPWITMP is DOUBLE PRECISION array, dimension (N) Like WR, WI, these arrays contain the eigenvalues of A, but sorted by increasing real part.
VSVS is DOUBLE PRECISION array, dimension (LDVS, N) VS holds the computed Schur vectors.
LDVSLDVS is INTEGER Leading dimension of VS. Must be at least max(1, N).
VS1VS1 is DOUBLE PRECISION array, dimension (LDVS, N) VS1 holds another copy of the computed Schur vectors.
RCDEINRCDEIN is DOUBLE PRECISION When COMP = .TRUE. RCDEIN holds the precomputed reciprocal condition number for the average of selected eigenvalues.
RCDVINRCDVIN is DOUBLE PRECISION When COMP = .TRUE. RCDVIN holds the precomputed reciprocal condition number for the selected right invariant subspace.
NSLCTNSLCT is INTEGER When COMP = .TRUE. the number of selected eigenvalues corresponding to the precomputed values RCDEIN and RCDVIN.
ISLCTISLCT is INTEGER array, dimension (NSLCT) When COMP = .TRUE. ISLCT selects the eigenvalues of the input matrix corresponding to the precomputed values RCDEIN and RCDVIN. For I=1, ... ,NSLCT, if ISLCT(I) = J, then the eigenvalue with the Jth largest real part is selected. Not referenced if COMP = .FALSE.
RESULTRESULT is DOUBLE PRECISION array, dimension (17) The values computed by the 17 tests described above. The values are currently limited to 1/ulp, to avoid overflow.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The number of entries in WORK to be passed to DGEESX. This must be at least 3*N, and N+N**2 if tests 1416 are to be performed.
IWORKIWORK is INTEGER array, dimension (N*N)
BWORKBWORK is LOGICAL array, dimension (N)
INFOINFO is INTEGER If 0, successful exit. If <0, input parameter INFO had an incorrect value. If >0, DGEESX returned an error code, the absolute value of which is returned.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget31 (double precision RMAX, integer LMAX, integer, dimension( 2 ) NINFO, integer KNT)
DGET31
Purpose:

DGET31 tests DLALN2, a routine for solving (ca A  w D)X = sB where A is an NA by NA matrix (NA=1 or 2 only), w is a real (NW=1) or complex (NW=2) constant, ca is a real constant, D is an NA by NA real diagonal matrix, and B is an NA by NW matrix (when NW=2 the second column of B contains the imaginary part of the solution). The code returns X and s, where s is a scale factor, less than or equal to 1, which is chosen to avoid overflow in X. If any singular values of ca Aw D are less than another input parameter SMIN, they are perturbed up to SMIN. The test condition is that the scaled residual norm( (ca Aw D)*X  s*B ) / ( max( ulp*norm(ca Aw D), SMIN )*norm(X) ) should be on the order of 1. Here, ulp is the machine precision. Also, it is verified that SCALE is less than or equal to 1, and that XNORM = infinitynorm(X).
Parameters:

RMAX
RMAX is DOUBLE PRECISION Value of the largest test ratio.
LMAXLMAX is INTEGER Example number where largest test ratio achieved.
NINFONINFO is INTEGER array, dimension (3) NINFO(1) = number of examples with INFO less than 0 NINFO(2) = number of examples with INFO greater than 0
KNTKNT is INTEGER Total number of examples tested.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget32 (double precision RMAX, integer LMAX, integer NINFO, integer KNT)
DGET32
Purpose:

DGET32 tests DLASY2, a routine for solving op(TL)*X + ISGN*X*op(TR) = SCALE*B where TL is N1 by N1, TR is N2 by N2, and N1,N2 =1 or 2 only. X and B are N1 by N2, op() is an optional transpose, an ISGN = 1 or 1. SCALE is chosen less than or equal to 1 to avoid overflow in X. The test condition is that the scaled residual norm( op(TL)*X + ISGN*X*op(TR) = SCALE*B ) / ( max( ulp*norm(TL), ulp*norm(TR)) * norm(X), SMLNUM ) should be on the order of 1. Here, ulp is the machine precision. Also, it is verified that SCALE is less than or equal to 1, and that XNORM = infinitynorm(X).
Parameters:

RMAX
RMAX is DOUBLE PRECISION Value of the largest test ratio.
LMAXLMAX is INTEGER Example number where largest test ratio achieved.
NINFONINFO is INTEGER Number of examples returned with INFO.NE.0.
KNTKNT is INTEGER Total number of examples tested.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget33 (double precision RMAX, integer LMAX, integer NINFO, integer KNT)
DGET33
Purpose:

DGET33 tests DLANV2, a routine for putting 2 by 2 blocks into standard form. In other words, it computes a two by two rotation [[C,S];[S,C]] where in [ C S ][T(1,1) T(1,2)][ C S ] = [ T11 T12 ] [S C ][T(2,1) T(2,2)][ S C ] [ T21 T22 ] either 1) T21=0 (real eigenvalues), or 2) T11=T22 and T21*T12<0 (complex conjugate eigenvalues). We also verify that the residual is small.
Parameters:

RMAX
RMAX is DOUBLE PRECISION Value of the largest test ratio.
LMAXLMAX is INTEGER Example number where largest test ratio achieved.
NINFONINFO is INTEGER Number of examples returned with INFO .NE. 0.
KNTKNT is INTEGER Total number of examples tested.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget34 (double precision RMAX, integer LMAX, integer, dimension( 2 ) NINFO, integer KNT)
DGET34
Purpose:

DGET34 tests DLAEXC, a routine for swapping adjacent blocks (either 1 by 1 or 2 by 2) on the diagonal of a matrix in real Schur form. Thus, DLAEXC computes an orthogonal matrix Q such that Q' * [ A B ] * Q = [ C1 B1 ] [ 0 C ] [ 0 A1 ] where C1 is similar to C and A1 is similar to A. Both A and C are assumed to be in standard form (equal diagonal entries and offdiagonal with differing signs) and A1 and C1 are returned with the same properties. The test code verifies these last last assertions, as well as that the residual in the above equation is small.
Parameters:

RMAX
RMAX is DOUBLE PRECISION Value of the largest test ratio.
LMAXLMAX is INTEGER Example number where largest test ratio achieved.
NINFONINFO is INTEGER array, dimension (2) NINFO(J) is the number of examples where INFO=J occurred.
KNTKNT is INTEGER Total number of examples tested.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget35 (double precision RMAX, integer LMAX, integer NINFO, integer KNT)
DGET35
Purpose:

DGET35 tests DTRSYL, a routine for solving the Sylvester matrix equation op(A)*X + ISGN*X*op(B) = scale*C, A and B are assumed to be in Schur canonical form, op() represents an optional transpose, and ISGN can be 1 or +1. Scale is an output less than or equal to 1, chosen to avoid overflow in X. The test code verifies that the following residual is order 1: norm(op(A)*X + ISGN*X*op(B)  scale*C) / (EPS*max(norm(A),norm(B))*norm(X))
Parameters:

RMAX
RMAX is DOUBLE PRECISION Value of the largest test ratio.
LMAXLMAX is INTEGER Example number where largest test ratio achieved.
NINFONINFO is INTEGER Number of examples where INFO is nonzero.
KNTKNT is INTEGER Total number of examples tested.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget36 (double precision RMAX, integer LMAX, integer, dimension( 3 ) NINFO, integer KNT, integer NIN)
DGET36
Purpose:

DGET36 tests DTREXC, a routine for moving blocks (either 1 by 1 or 2 by 2) on the diagonal of a matrix in real Schur form. Thus, DLAEXC computes an orthogonal matrix Q such that Q' * T1 * Q = T2 and where one of the diagonal blocks of T1 (the one at row IFST) has been moved to position ILST. The test code verifies that the residual Q'*T1*QT2 is small, that T2 is in Schur form, and that the final position of the IFST block is ILST (within +1). The test matrices are read from a file with logical unit number NIN.
Parameters:

RMAX
RMAX is DOUBLE PRECISION Value of the largest test ratio.
LMAXLMAX is INTEGER Example number where largest test ratio achieved.
NINFONINFO is INTEGER array, dimension (3) NINFO(J) is the number of examples where INFO=J.
KNTKNT is INTEGER Total number of examples tested.
NINNIN is INTEGER Input logical unit number.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget37 (double precision, dimension( 3 ) RMAX, integer, dimension( 3 ) LMAX, integer, dimension( 3 ) NINFO, integer KNT, integer NIN)
DGET37
Purpose:

DGET37 tests DTRSNA, a routine for estimating condition numbers of eigenvalues and/or right eigenvectors of a matrix. The test matrices are read from a file with logical unit number NIN.
Parameters:

RMAX
RMAX is DOUBLE PRECISION array, dimension (3) Value of the largest test ratio. RMAX(1) = largest ratio comparing different calls to DTRSNA RMAX(2) = largest error in reciprocal condition numbers taking their conditioning into account RMAX(3) = largest error in reciprocal condition numbers not taking their conditioning into account (may be larger than RMAX(2))
LMAXLMAX is INTEGER array, dimension (3) LMAX(i) is example number where largest test ratio RMAX(i) is achieved. Also: If DGEHRD returns INFO nonzero on example i, LMAX(1)=i If DHSEQR returns INFO nonzero on example i, LMAX(2)=i If DTRSNA returns INFO nonzero on example i, LMAX(3)=i
NINFONINFO is INTEGER array, dimension (3) NINFO(1) = No. of times DGEHRD returned INFO nonzero NINFO(2) = No. of times DHSEQR returned INFO nonzero NINFO(3) = No. of times DTRSNA returned INFO nonzero
KNTKNT is INTEGER Total number of examples tested.
NINNIN is INTEGER Input logical unit number
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget38 (double precision, dimension( 3 ) RMAX, integer, dimension( 3 ) LMAX, integer, dimension( 3 ) NINFO, integer KNT, integer NIN)
DGET38
Purpose:

DGET38 tests DTRSEN, a routine for estimating condition numbers of a cluster of eigenvalues and/or its associated right invariant subspace The test matrices are read from a file with logical unit number NIN.
Parameters:

RMAX
RMAX is DOUBLE PRECISION array, dimension (3) Values of the largest test ratios. RMAX(1) = largest residuals from DHST01 or comparing different calls to DTRSEN RMAX(2) = largest error in reciprocal condition numbers taking their conditioning into account RMAX(3) = largest error in reciprocal condition numbers not taking their conditioning into account (may be larger than RMAX(2))
LMAXLMAX is INTEGER array, dimension (3) LMAX(i) is example number where largest test ratio RMAX(i) is achieved. Also: If DGEHRD returns INFO nonzero on example i, LMAX(1)=i If DHSEQR returns INFO nonzero on example i, LMAX(2)=i If DTRSEN returns INFO nonzero on example i, LMAX(3)=i
NINFONINFO is INTEGER array, dimension (3) NINFO(1) = No. of times DGEHRD returned INFO nonzero NINFO(2) = No. of times DHSEQR returned INFO nonzero NINFO(3) = No. of times DTRSEN returned INFO nonzero
KNTKNT is INTEGER Total number of examples tested.
NINNIN is INTEGER Input logical unit number.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget39 (double precision RMAX, integer LMAX, integer NINFO, integer KNT)
DGET39
Purpose:

DGET39 tests DLAQTR, a routine for solving the real or special complex quasi upper triangular system op(T)*p = scale*c, or op(T + iB)*(p+iq) = scale*(c+id), in real arithmetic. T is upper quasitriangular. If it is complex, then the first diagonal block of T must be 1 by 1, B has the special structure B = [ b(1) b(2) ... b(n) ] [ w ] [ w ] [ . ] [ w ] op(A) = A or A', where A' denotes the conjugate transpose of the matrix A. On input, X = [ c ]. On output, X = [ p ]. [ d ] [ q ] Scale is an output less than or equal to 1, chosen to avoid overflow in X. This subroutine is specially designed for the condition number estimation in the eigenproblem routine DTRSNA. The test code verifies that the following residual is order 1: (T+i*B)*(x1+i*x2)  scale*(d1+i*d2)  max(ulp*(T+B)*(x1+x2), (T+B)*smlnum/ulp, smlnum) (The (T+B)*smlnum/ulp term accounts for possible (gradual or nongradual) underflow in x1 and x2.)
Parameters:

RMAX
RMAX is DOUBLE PRECISION Value of the largest test ratio.
LMAXLMAX is INTEGER Example number where largest test ratio achieved.
NINFONINFO is INTEGER Number of examples where INFO is nonzero.
KNTKNT is INTEGER Total number of examples tested.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget51 (integer ITYPE, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( * ) WORK, double precision RESULT)
DGET51
Purpose:

DGET51 generally checks a decomposition of the form A = U B V' where ' means transpose and U and V are orthogonal. Specifically, if ITYPE=1 RESULT =  A  U B V'  / ( A n ulp ) If ITYPE=2, then: RESULT =  A  B  / ( A n ulp ) If ITYPE=3, then: RESULT =  I  UU'  / ( n ulp )
Parameters:

ITYPE
ITYPE is INTEGER Specifies the type of tests to be performed. =1: RESULT =  A  U B V'  / ( A n ulp ) =2: RESULT =  A  B  / ( A n ulp ) =3: RESULT =  I  UU'  / ( n ulp )
NN is INTEGER The size of the matrix. If it is zero, DGET51 does nothing. It must be at least zero.
AA is DOUBLE PRECISION array, dimension (LDA, N) The original (unfactored) matrix.
LDALDA is INTEGER The leading dimension of A. It must be at least 1 and at least N.
BB is DOUBLE PRECISION array, dimension (LDB, N) The factored matrix.
LDBLDB is INTEGER The leading dimension of B. It must be at least 1 and at least N.
UU is DOUBLE PRECISION array, dimension (LDU, N) The orthogonal matrix on the lefthand side in the decomposition. Not referenced if ITYPE=2
LDULDU is INTEGER The leading dimension of U. LDU must be at least N and at least 1.
VV is DOUBLE PRECISION array, dimension (LDV, N) The orthogonal matrix on the lefthand side in the decomposition. Not referenced if ITYPE=2
LDVLDV is INTEGER The leading dimension of V. LDV must be at least N and at least 1.
WORKWORK is DOUBLE PRECISION array, dimension (2*N**2)
RESULTRESULT is DOUBLE PRECISION The values computed by the test specified by ITYPE. The value is currently limited to 1/ulp, to avoid overflow. Errors are flagged by RESULT=10/ulp.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget52 (logical LEFT, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( lde, * ) E, integer LDE, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)
DGET52
Purpose:

DGET52 does an eigenvector check for the generalized eigenvalue problem. The basic test for right eigenvectors is:  b(j) A E(j)  a(j) B E(j)  RESULT(1) = max  j n ulp max( b(j) A, a(j) B ) using the 1norm. Here, a(j)/b(j) = w is the jth generalized eigenvalue of A  w B, or, equivalently, b(j)/a(j) = m is the jth generalized eigenvalue of m A  B. For real eigenvalues, the test is straightforward. For complex eigenvalues, E(j) and a(j) are complex, represented by Er(j) + i*Ei(j) and ar(j) + i*ai(j), resp., so the test for that eigenvector becomes max( Wr, Wi )  n ulp max( b(j) A, (ar(j)+ai(j)) B ) where Wr = b(j) A Er(j)  ar(j) B Er(j) + ai(j) B Ei(j) Wi = b(j) A Ei(j)  ai(j) B Er(j)  ar(j) B Ei(j) T T _ For left eigenvectors, A , B , a, and b are used. DGET52 also tests the normalization of E. Each eigenvector is supposed to be normalized so that the maximum "absolute value" of its elements is 1, where in this case, "absolute value" of a complex value x is Re(x) + Im(x) ; let us call this maximum "absolute value" norm of a vector v M(v). if a(j)=b(j)=0, then the eigenvector is set to be the jth coordinate vector. The normalization test is: RESULT(2) = max  M(v(j))  1  / ( n ulp ) eigenvectors v(j)
Parameters:

LEFT
LEFT is LOGICAL =.TRUE.: The eigenvectors in the columns of E are assumed to be *left* eigenvectors. =.FALSE.: The eigenvectors in the columns of E are assumed to be *right* eigenvectors.
NN is INTEGER The size of the matrices. If it is zero, DGET52 does nothing. It must be at least zero.
AA is DOUBLE PRECISION array, dimension (LDA, N) The matrix A.
LDALDA is INTEGER The leading dimension of A. It must be at least 1 and at least N.
BB is DOUBLE PRECISION array, dimension (LDB, N) The matrix B.
LDBLDB is INTEGER The leading dimension of B. It must be at least 1 and at least N.
EE is DOUBLE PRECISION array, dimension (LDE, N) The matrix of eigenvectors. It must be O( 1 ). Complex eigenvalues and eigenvectors always come in pairs, the eigenvalue and its conjugate being stored in adjacent elements of ALPHAR, ALPHAI, and BETA. Thus, if a(j)/b(j) and a(j+1)/b(j+1) are a complex conjugate pair of generalized eigenvalues, then E(,j) contains the real part of the eigenvector and E(,j+1) contains the imaginary part. Note that whether E(,j) is a real eigenvector or part of a complex one is specified by whether ALPHAI(j) is zero or not.
LDELDE is INTEGER The leading dimension of E. It must be at least 1 and at least N.
ALPHARALPHAR is DOUBLE PRECISION array, dimension (N) The real parts of the values a(j) as described above, which, along with b(j), define the generalized eigenvalues. Complex eigenvalues always come in complex conjugate pairs a(j)/b(j) and a(j+1)/b(j+1), which are stored in adjacent elements in ALPHAR, ALPHAI, and BETA. Thus, if the jth and (j+1)st eigenvalues form a pair, ALPHAR(j+1)/BETA(j+1) is assumed to be equal to ALPHAR(j)/BETA(j).
ALPHAIALPHAI is DOUBLE PRECISION array, dimension (N) The imaginary parts of the values a(j) as described above, which, along with b(j), define the generalized eigenvalues. If ALPHAI(j)=0, then the eigenvalue is real, otherwise it is part of a complex conjugate pair. Complex eigenvalues always come in complex conjugate pairs a(j)/b(j) and a(j+1)/b(j+1), which are stored in adjacent elements in ALPHAR, ALPHAI, and BETA. Thus, if the jth and (j+1)st eigenvalues form a pair, ALPHAI(j+1)/BETA(j+1) is assumed to be equal to ALPHAI(j)/BETA(j). Also, nonzero values in ALPHAI are assumed to always come in adjacent pairs.
BETABETA is DOUBLE PRECISION array, dimension (N) The values b(j) as described above, which, along with a(j), define the generalized eigenvalues.
WORKWORK is DOUBLE PRECISION array, dimension (N**2+N)
RESULTRESULT is DOUBLE PRECISION array, dimension (2) The values computed by the test described above. If A E or B E is likely to overflow, then RESULT(1:2) is set to 10 / ulp.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget53 (double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision SCALE, double precision WR, double precision WI, double precision RESULT, integer INFO)
DGET53
Purpose:

DGET53 checks the generalized eigenvalues computed by DLAG2. The basic test for an eigenvalue is:  det( s A  w B )  RESULT =  ulp max( s norm(A), w norm(B) )*norm( s A  w B ) Two "safety checks" are performed: (1) ulp*max( s*norm(A), w*norm(B) ) must be at least safe_minimum. This insures that the test performed is not essentially det(0*A + 0*B)=0. (2) s*norm(A) + w*norm(B) must be less than 1/safe_minimum. This insures that s*A  w*B will not overflow. If these tests are not passed, then s and w are scaled and tested anyway, if this is possible.
Parameters:

A
A is DOUBLE PRECISION array, dimension (LDA, 2) The 2x2 matrix A.
LDALDA is INTEGER The leading dimension of A. It must be at least 2.
BB is DOUBLE PRECISION array, dimension (LDB, N) The 2x2 uppertriangular matrix B.
LDBLDB is INTEGER The leading dimension of B. It must be at least 2.
SCALESCALE is DOUBLE PRECISION The "scale factor" s in the formula s A  w B . It is assumed to be nonnegative.
WRWR is DOUBLE PRECISION The real part of the eigenvalue w in the formula s A  w B .
WIWI is DOUBLE PRECISION The imaginary part of the eigenvalue w in the formula s A  w B .
RESULTRESULT is DOUBLE PRECISION If INFO is 2 or less, the value computed by the test described above. If INFO=3, this will just be 1/ulp.
INFOINFO is INTEGER =0: The input data pass the "safety checks". =1: s*norm(A) + w*norm(B) > 1/safe_minimum. =2: ulp*max( s*norm(A), w*norm(B) ) < safe_minimum =3: same as INFO=2, but s and w could not be scaled so as to compute the test.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dget54 (integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( lds, * ) S, integer LDS, double precision, dimension( ldt, * ) T, integer LDT, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( * ) WORK, double precision RESULT)
DGET54
Purpose:

DGET54 checks a generalized decomposition of the form A = U*S*V' and B = U*T* V' where ' means transpose and U and V are orthogonal. Specifically, RESULT = ( A  U*S*V', B  U*T*V' ) / (( A, B )*n*ulp )
Parameters:

N
N is INTEGER The size of the matrix. If it is zero, DGET54 does nothing. It must be at least zero.
AA is DOUBLE PRECISION array, dimension (LDA, N) The original (unfactored) matrix A.
LDALDA is INTEGER The leading dimension of A. It must be at least 1 and at least N.
BB is DOUBLE PRECISION array, dimension (LDB, N) The original (unfactored) matrix B.
LDBLDB is INTEGER The leading dimension of B. It must be at least 1 and at least N.
SS is DOUBLE PRECISION array, dimension (LDS, N) The factored matrix S.
LDSLDS is INTEGER The leading dimension of S. It must be at least 1 and at least N.
TT is DOUBLE PRECISION array, dimension (LDT, N) The factored matrix T.
LDTLDT is INTEGER The leading dimension of T. It must be at least 1 and at least N.
UU is DOUBLE PRECISION array, dimension (LDU, N) The orthogonal matrix on the lefthand side in the decomposition.
LDULDU is INTEGER The leading dimension of U. LDU must be at least N and at least 1.
VV is DOUBLE PRECISION array, dimension (LDV, N) The orthogonal matrix on the lefthand side in the decomposition.
LDVLDV is INTEGER The leading dimension of V. LDV must be at least N and at least 1.
WORKWORK is DOUBLE PRECISION array, dimension (3*N**2)
RESULTRESULT is DOUBLE PRECISION The value RESULT, It is currently limited to 1/ulp, to avoid overflow. Errors are flagged by RESULT=10/ulp.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dglmts (integer N, integer M, integer P, double precision, dimension( lda, * ) A, double precision, dimension( lda, * ) AF, integer LDA, double precision, dimension( ldb, * ) B, double precision, dimension( ldb, * ) BF, integer LDB, double precision, dimension( * ) D, double precision, dimension( * ) DF, double precision, dimension( * ) X, double precision, dimension( * ) U, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision RESULT)
DGLMTS
Purpose:

DGLMTS tests DGGGLM  a subroutine for solving the generalized linear model problem.
Parameters:

N
N is INTEGER The number of rows of the matrices A and B. N >= 0.
MM is INTEGER The number of columns of the matrix A. M >= 0.
PP is INTEGER The number of columns of the matrix B. P >= 0.
AA is DOUBLE PRECISION array, dimension (LDA,M) The NbyM matrix A.
AFAF is DOUBLE PRECISION array, dimension (LDA,M)
LDALDA is INTEGER The leading dimension of the arrays A, AF. LDA >= max(M,N).
BB is DOUBLE PRECISION array, dimension (LDB,P) The NbyP matrix A.
BFBF is DOUBLE PRECISION array, dimension (LDB,P)
LDBLDB is INTEGER The leading dimension of the arrays B, BF. LDB >= max(P,N).
DD is DOUBLE PRECISION array, dimension( N ) On input, the left hand side of the GLM.
DFDF is DOUBLE PRECISION array, dimension( N )
XX is DOUBLE PRECISION array, dimension( M ) solution vector X in the GLM problem.
UU is DOUBLE PRECISION array, dimension( P ) solution vector U in the GLM problem.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The dimension of the array WORK.
RWORKRWORK is DOUBLE PRECISION array, dimension (M)
RESULTRESULT is DOUBLE PRECISION The test ratio: norm( d  A*x  B*u ) RESULT =  (norm(A)+norm(B))*(norm(x)+norm(u))*EPS
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dgqrts (integer N, integer M, integer P, double precision, dimension( lda, * ) A, double precision, dimension( lda, * ) AF, double precision, dimension( lda, * ) Q, double precision, dimension( lda, * ) R, integer LDA, double precision, dimension( * ) TAUA, double precision, dimension( ldb, * ) B, double precision, dimension( ldb, * ) BF, double precision, dimension( ldb, * ) Z, double precision, dimension( ldb, * ) T, double precision, dimension( ldb, * ) BWK, integer LDB, double precision, dimension( * ) TAUB, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 4 ) RESULT)
DGQRTS
Purpose:

DGQRTS tests DGGQRF, which computes the GQR factorization of an NbyM matrix A and a NbyP matrix B: A = Q*R and B = Q*T*Z.
Parameters:

N
N is INTEGER The number of rows of the matrices A and B. N >= 0.
MM is INTEGER The number of columns of the matrix A. M >= 0.
PP is INTEGER The number of columns of the matrix B. P >= 0.
AA is DOUBLE PRECISION array, dimension (LDA,M) The NbyM matrix A.
AFAF is DOUBLE PRECISION array, dimension (LDA,N) Details of the GQR factorization of A and B, as returned by DGGQRF, see SGGQRF for further details.
QQ is DOUBLE PRECISION array, dimension (LDA,N) The MbyM orthogonal matrix Q.
RR is DOUBLE PRECISION array, dimension (LDA,MAX(M,N))
LDALDA is INTEGER The leading dimension of the arrays A, AF, R and Q. LDA >= max(M,N).
TAUATAUA is DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by DGGQRF.
BB is DOUBLE PRECISION array, dimension (LDB,P) On entry, the NbyP matrix A.
BFBF is DOUBLE PRECISION array, dimension (LDB,N) Details of the GQR factorization of A and B, as returned by DGGQRF, see SGGQRF for further details.
ZZ is DOUBLE PRECISION array, dimension (LDB,P) The PbyP orthogonal matrix Z.
TT is DOUBLE PRECISION array, dimension (LDB,max(P,N))
BWKBWK is DOUBLE PRECISION array, dimension (LDB,N)
LDBLDB is INTEGER The leading dimension of the arrays B, BF, Z and T. LDB >= max(P,N).
TAUBTAUB is DOUBLE PRECISION array, dimension (min(P,N)) The scalar factors of the elementary reflectors, as returned by DGGRQF.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The dimension of the array WORK, LWORK >= max(N,M,P)**2.
RWORKRWORK is DOUBLE PRECISION array, dimension (max(N,M,P))
RESULTRESULT is DOUBLE PRECISION array, dimension (4) The test ratios: RESULT(1) = norm( R  Q'*A ) / ( MAX(M,N)*norm(A)*ULP) RESULT(2) = norm( T*Z  Q'*B ) / (MAX(P,N)*norm(B)*ULP) RESULT(3) = norm( I  Q'*Q ) / ( M*ULP ) RESULT(4) = norm( I  Z'*Z ) / ( P*ULP )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dgrqts (integer M, integer P, integer N, double precision, dimension( lda, * ) A, double precision, dimension( lda, * ) AF, double precision, dimension( lda, * ) Q, double precision, dimension( lda, * ) R, integer LDA, double precision, dimension( * ) TAUA, double precision, dimension( ldb, * ) B, double precision, dimension( ldb, * ) BF, double precision, dimension( ldb, * ) Z, double precision, dimension( ldb, * ) T, double precision, dimension( ldb, * ) BWK, integer LDB, double precision, dimension( * ) TAUB, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 4 ) RESULT)
DGRQTS
Purpose:

DGRQTS tests DGGRQF, which computes the GRQ factorization of an MbyN matrix A and a PbyN matrix B: A = R*Q and B = Z*T*Q.
Parameters:

M
M is INTEGER The number of rows of the matrix A. M >= 0.
PP is INTEGER The number of rows of the matrix B. P >= 0.
NN is INTEGER The number of columns of the matrices A and B. N >= 0.
AA is DOUBLE PRECISION array, dimension (LDA,N) The MbyN matrix A.
AFAF is DOUBLE PRECISION array, dimension (LDA,N) Details of the GRQ factorization of A and B, as returned by DGGRQF, see SGGRQF for further details.
QQ is DOUBLE PRECISION array, dimension (LDA,N) The NbyN orthogonal matrix Q.
RR is DOUBLE PRECISION array, dimension (LDA,MAX(M,N))
LDALDA is INTEGER The leading dimension of the arrays A, AF, R and Q. LDA >= max(M,N).
TAUATAUA is DOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by DGGQRC.
BB is DOUBLE PRECISION array, dimension (LDB,N) On entry, the PbyN matrix A.
BFBF is DOUBLE PRECISION array, dimension (LDB,N) Details of the GQR factorization of A and B, as returned by DGGRQF, see SGGRQF for further details.
ZZ is DOUBLE PRECISION array, dimension (LDB,P) The PbyP orthogonal matrix Z.
TT is DOUBLE PRECISION array, dimension (LDB,max(P,N))
BWKBWK is DOUBLE PRECISION array, dimension (LDB,N)
LDBLDB is INTEGER The leading dimension of the arrays B, BF, Z and T. LDB >= max(P,N).
TAUBTAUB is DOUBLE PRECISION array, dimension (min(P,N)) The scalar factors of the elementary reflectors, as returned by DGGRQF.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The dimension of the array WORK, LWORK >= max(M,P,N)**2.
RWORKRWORK is DOUBLE PRECISION array, dimension (M)
RESULTRESULT is DOUBLE PRECISION array, dimension (4) The test ratios: RESULT(1) = norm( R  A*Q' ) / ( MAX(M,N)*norm(A)*ULP) RESULT(2) = norm( T*Q  Z'*B ) / (MAX(P,N)*norm(B)*ULP) RESULT(3) = norm( I  Q'*Q ) / ( N*ULP ) RESULT(4) = norm( I  Z'*Z ) / ( P*ULP )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dgsvts3 (integer M, integer P, integer N, double precision, dimension( lda, * ) A, double precision, dimension( lda, * ) AF, integer LDA, double precision, dimension( ldb, * ) B, double precision, dimension( ldb, * ) BF, integer LDB, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( * ) ALPHA, double precision, dimension( * ) BETA, double precision, dimension( ldr, * ) R, integer LDR, integer, dimension( * ) IWORK, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 6 ) RESULT)
DGSVTS3
Purpose:

DGSVTS3 tests DGGSVD3, which computes the GSVD of an MbyN matrix A and a PbyN matrix B: U'*A*Q = D1*R and V'*B*Q = D2*R.
Parameters:

M
M is INTEGER The number of rows of the matrix A. M >= 0.
PP is INTEGER The number of rows of the matrix B. P >= 0.
NN is INTEGER The number of columns of the matrices A and B. N >= 0.
AA is DOUBLE PRECISION array, dimension (LDA,M) The MbyN matrix A.
AFAF is DOUBLE PRECISION array, dimension (LDA,N) Details of the GSVD of A and B, as returned by DGGSVD3, see DGGSVD3 for further details.
LDALDA is INTEGER The leading dimension of the arrays A and AF. LDA >= max( 1,M ).
BB is DOUBLE PRECISION array, dimension (LDB,P) On entry, the PbyN matrix B.
BFBF is DOUBLE PRECISION array, dimension (LDB,N) Details of the GSVD of A and B, as returned by DGGSVD3, see DGGSVD3 for further details.
LDBLDB is INTEGER The leading dimension of the arrays B and BF. LDB >= max(1,P).
UU is DOUBLE PRECISION array, dimension(LDU,M) The M by M orthogonal matrix U.
LDULDU is INTEGER The leading dimension of the array U. LDU >= max(1,M).
VV is DOUBLE PRECISION array, dimension(LDV,M) The P by P orthogonal matrix V.
LDVLDV is INTEGER The leading dimension of the array V. LDV >= max(1,P).
QQ is DOUBLE PRECISION array, dimension(LDQ,N) The N by N orthogonal matrix Q.
LDQLDQ is INTEGER The leading dimension of the array Q. LDQ >= max(1,N).
ALPHAALPHA is DOUBLE PRECISION array, dimension (N)
BETABETA is DOUBLE PRECISION array, dimension (N) The generalized singular value pairs of A and B, the ``diagonal'' matrices D1 and D2 are constructed from ALPHA and BETA, see subroutine DGGSVD3 for details.
RR is DOUBLE PRECISION array, dimension(LDQ,N) The upper triangular matrix R.
LDRLDR is INTEGER The leading dimension of the array R. LDR >= max(1,N).
IWORKIWORK is INTEGER array, dimension (N)
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The dimension of the array WORK, LWORK >= max(M,P,N)*max(M,P,N).
RWORKRWORK is DOUBLE PRECISION array, dimension (max(M,P,N))
RESULTRESULT is DOUBLE PRECISION array, dimension (6) The test ratios: RESULT(1) = norm( U'*A*Q  D1*R ) / ( MAX(M,N)*norm(A)*ULP) RESULT(2) = norm( V'*B*Q  D2*R ) / ( MAX(P,N)*norm(B)*ULP) RESULT(3) = norm( I  U'*U ) / ( M*ULP ) RESULT(4) = norm( I  V'*V ) / ( P*ULP ) RESULT(5) = norm( I  Q'*Q ) / ( N*ULP ) RESULT(6) = 0 if ALPHA is in decreasing order; = ULPINV otherwise.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 August 2015
subroutine dhst01 (integer N, integer ILO, integer IHI, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldh, * ) H, integer LDH, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( 2 ) RESULT)
DHST01
Purpose:

DHST01 tests the reduction of a general matrix A to upper Hessenberg form: A = Q*H*Q'. Two test ratios are computed; RESULT(1) = norm( A  Q*H*Q' ) / ( norm(A) * N * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( N * EPS ) The matrix Q is assumed to be given explicitly as it would be following DGEHRD + DORGHR. In this version, ILO and IHI are not used and are assumed to be 1 and N, respectively.
Parameters:

N
N is INTEGER The order of the matrix A. N >= 0.
ILOILO is INTEGER
IHIIHI is INTEGER A is assumed to be upper triangular in rows and columns 1:ILO1 and IHI+1:N, so Q differs from the identity only in rows and columns ILO+1:IHI.
AA is DOUBLE PRECISION array, dimension (LDA,N) The original n by n matrix A.
LDALDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
HH is DOUBLE PRECISION array, dimension (LDH,N) The upper Hessenberg matrix H from the reduction A = Q*H*Q' as computed by DGEHRD. H is assumed to be zero below the first subdiagonal.
LDHLDH is INTEGER The leading dimension of the array H. LDH >= max(1,N).
QQ is DOUBLE PRECISION array, dimension (LDQ,N) The orthogonal matrix Q from the reduction A = Q*H*Q' as computed by DGEHRD + DORGHR.
LDQLDQ is INTEGER The leading dimension of the array Q. LDQ >= max(1,N).
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The length of the array WORK. LWORK >= 2*N*N.
RESULTRESULT is DOUBLE PRECISION array, dimension (2) RESULT(1) = norm( A  Q*H*Q' ) / ( norm(A) * N * 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 dlafts (character*3 TYPE, integer M, integer N, integer IMAT, integer NTESTS, double precision, dimension( * ) RESULT, integer, dimension( 4 ) ISEED, double precision THRESH, integer IOUNIT, integer IE)
DLAFTS
Purpose:

DLAFTS tests the result vector against the threshold value to see which tests for this matrix type failed to pass the threshold. Output is to the file given by unit IOUNIT.
TYPE  CHARACTER*3 On entry, TYPE specifies the matrix type to be used in the printed messages. Not modified. N  INTEGER On entry, N specifies the order of the test matrix. Not modified. IMAT  INTEGER On entry, IMAT specifies the type of the test matrix. A listing of the different types is printed by DLAHD2 to the output file if a test fails to pass the threshold. Not modified. NTESTS  INTEGER On entry, NTESTS is the number of tests performed on the subroutines in the path given by TYPE. Not modified. RESULT  DOUBLE PRECISION array of dimension( NTESTS ) On entry, RESULT contains the test ratios from the tests performed in the calling program. Not modified. ISEED  INTEGER array of dimension( 4 ) Contains the random seed that generated the matrix used for the tests whose ratios are in RESULT. Not modified. THRESH  DOUBLE PRECISION On entry, THRESH specifies the acceptable threshold of the test ratios. If RESULT( K ) > THRESH, then the Kth test did not pass the threshold and a message will be printed. Not modified. IOUNIT  INTEGER On entry, IOUNIT specifies the unit number of the file to which the messages are printed. Not modified. IE  INTEGER On entry, IE contains the number of tests which have failed to pass the threshold so far. Updated on exit if any of the ratios in RESULT also fail.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dlahd2 (integer IOUNIT, character*3 PATH)
DLAHD2
Purpose:

DLAHD2 prints header information for the different test paths.
Parameters:

IOUNIT
IOUNIT is INTEGER. On entry, IOUNIT specifies the unit number to which the header information should be printed.
PATHPATH is CHARACTER*3. On entry, PATH contains the name of the path for which the header information is to be printed. Current paths are DHS, ZHS: Nonsymmetric eigenproblem. DST, ZST: Symmetric eigenproblem. DSG, ZSG: Symmetric Generalized eigenproblem. DBD, ZBD: Singular Value Decomposition (SVD) DBB, ZBB: General Banded reduction to bidiagonal form These paths also are supplied in double precision (replace leading S by D and leading C by Z in path names).
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2015
subroutine dlarfy (character UPLO, integer N, double precision, dimension( * ) V, integer INCV, double precision TAU, double precision, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) WORK)
DLARFY
Purpose:

DLARFY applies an elementary reflector, or Householder matrix, H, to an n x n symmetric matrix C, from both the left and the right. H is represented in the form H = I  tau * v * v' where tau is a scalar and v is a vector. If tau is zero, then H is taken to be the unit matrix.
Parameters:

UPLO
UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the symmetric matrix C is stored. = 'U': Upper triangle = 'L': Lower triangle
NN is INTEGER The number of rows and columns of the matrix C. N >= 0.
VV is DOUBLE PRECISION array, dimension (1 + (N1)*abs(INCV)) The vector v as described above.
INCVINCV is INTEGER The increment between successive elements of v. INCV must not be zero.
TAUTAU is DOUBLE PRECISION The value tau as described above.
CC is DOUBLE PRECISION array, dimension (LDC, N) On entry, the matrix C. On exit, C is overwritten by H * C * H'.
LDCLDC is INTEGER The leading dimension of the array C. LDC >= max( 1, N ).
WORKWORK is DOUBLE PRECISION array, dimension (N)
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dlarhs (character*3 PATH, character XTYPE, character UPLO, character TRANS, integer M, integer N, integer KL, integer KU, integer NRHS, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldx, * ) X, integer LDX, double precision, dimension( ldb, * ) B, integer LDB, integer, dimension( 4 ) ISEED, integer INFO)
DLARHS
Purpose:

DLARHS chooses a set of NRHS random solution vectors and sets up the right hand sides for the linear system op( A ) * X = B, where op( A ) may be A or A' (transpose of A).
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, 2D storage xPP: Symmetric positive definite packed xPB: Symmetric positive definite banded xSY: Symmetric indefinite, 2D storage xSP: Symmetric indefinite packed xSB: Symmetric indefinite banded xTR: Triangular xTP: Triangular packed xTB: Triangular banded xQR: General m x n matrix xLQ: General m x n matrix xQL: General m x n matrix xRQ: General m x n matrix where the leading character indicates the precision.
XTYPEXTYPE 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.
UPLOUPLO 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
TRANSTRANS 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
MM is INTEGER The number or rows of the matrix A. M >= 0.
NN is INTEGER The number of columns of the matrix A. N >= 0.
KLKL is INTEGER Used only if A is a band matrix; specifies the number of subdiagonals of A if A is a general band matrix or if A is symmetric or triangular and UPLO = 'L'; specifies the number of superdiagonals of A if A is symmetric or triangular and UPLO = 'U'. 0 <= KL <= M1.
KUKU is INTEGER Used only if A is a general band matrix or if A is triangular. If PATH = xGB, specifies the number of superdiagonals of A, and 0 <= KU <= N1. If PATH = xTR, xTP, or xTB, specifies whether or not the matrix has unit diagonal: = 1: matrix has nonunit diagonal (default) = 2: matrix has unit diagonal
NRHSNRHS is INTEGER The number of right hand side vectors in the system A*X = B.
AA is DOUBLE PRECISION array, dimension (LDA,N) The test matrix whose type is given by PATH.
LDALDA 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).
XX is or output) DOUBLE PRECISION array, dimension(LDX,NRHS) On entry, if XTYPE = 'C' (for 'Computed'), then X contains the exact solution to the system of linear equations. On exit, if XTYPE = 'N' (for 'New'), then X is initialized with random values.
LDXLDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= max(1,N); if TRANS = 'T', LDX >= max(1,M).
BB is DOUBLE PRECISION array, dimension (LDB,NRHS) The right hand side vector(s) for the system of equations, computed from B = op(A) * X, where op(A) is determined by TRANS.
LDBLDB is INTEGER The leading dimension of the array B. If TRANS = 'N', LDB >= max(1,M); if TRANS = 'T', LDB >= max(1,N).
ISEEDISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in DLATMS). Modified on exit.
INFOINFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dlasum (character*3 TYPE, integer IOUNIT, integer IE, integer NRUN)
DLASUM
Purpose:

DLASUM prints a summary of the results from one of the test routines.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dlatb9 (character*3 PATH, integer IMAT, integer M, integer P, integer N, character TYPE, integer KLA, integer KUA, integer KLB, integer KUB, double precision ANORM, double precision BNORM, integer MODEA, integer MODEB, double precision CNDNMA, double precision CNDNMB, character DISTA, character DISTB)
DLATB9
Purpose:

DLATB9 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.
IMATIMAT is INTEGER An integer key describing which matrix to generate for this path. = 1: A: diagonal, B: upper triangular = 2: A: upper triangular, B: upper triangular = 3: A: lower triangular, B: upper triangular Else: A: general dense, B: general dense
MM is INTEGER The number of rows in the matrix to be generated.
PP is INTEGER
NN is INTEGER The number of columns in the matrix to be generated.
TYPETYPE is CHARACTER*1 The type of the matrix to be generated: = 'S': symmetric matrix; = 'P': symmetric positive (semi)definite matrix; = 'N': nonsymmetric matrix.
KLAKLA is INTEGER The lower band width of the matrix to be generated.
KUAKUA is INTEGER The upper band width of the matrix to be generated.
KLBKLB is INTEGER The lower band width of the matrix to be generated.
KUBKUA is INTEGER The upper band width of the matrix to be generated.
ANORMANORM is DOUBLE PRECISION The desired norm of the matrix to be generated. The diagonal matrix of singular values or eigenvalues is scaled by this value.
BNORMBNORM is DOUBLE PRECISION The desired norm of the matrix to be generated. The diagonal matrix of singular values or eigenvalues is scaled by this value.
MODEAMODEA is INTEGER A key indicating how to choose the vector of eigenvalues.
MODEBMODEB is INTEGER A key indicating how to choose the vector of eigenvalues.
CNDNMACNDNMA is DOUBLE PRECISION The desired condition number.
CNDNMBCNDNMB is DOUBLE PRECISION The desired condition number.
DISTADISTA is CHARACTER*1 The type of distribution to be used by the random number generator.
DISTBDISTB 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 dlatm4 (integer ITYPE, integer N, integer NZ1, integer NZ2, integer ISIGN, double precision AMAGN, double precision RCOND, double precision TRIANG, integer IDIST, integer, dimension( 4 ) ISEED, double precision, dimension( lda, * ) A, integer LDA)
DLATM4
Purpose:

DLATM4 generates basic square matrices, which may later be multiplied by others in order to produce test matrices. It is intended mainly to be used to test the generalized eigenvalue routines. It first generates the diagonal and (possibly) subdiagonal, according to the value of ITYPE, NZ1, NZ2, ISIGN, AMAGN, and RCOND. It then fills in the upper triangle with random numbers, if TRIANG is nonzero.
Parameters:

ITYPE
ITYPE is INTEGER The "type" of matrix on the diagonal and subdiagonal. If ITYPE < 0, then type abs(ITYPE) is generated and then swapped end for end (A(I,J) := A'(NJ,NI).) See also the description of AMAGN and ISIGN. Special types: = 0: the zero matrix. = 1: the identity. = 2: a transposed Jordan block. = 3: If N is odd, then a k+1 x k+1 transposed Jordan block followed by a k x k identity block, where k=(N1)/2. If N is even, then k=(N2)/2, and a zero diagonal entry is tacked onto the end. Diagonal types. The diagonal consists of NZ1 zeros, then k=NNZ1NZ2 nonzeros. The subdiagonal is zero. ITYPE specifies the nonzero diagonal entries as follows: = 4: 1, ..., k = 5: 1, RCOND, ..., RCOND = 6: 1, ..., 1, RCOND = 7: 1, a, a^2, ..., a^(k1)=RCOND = 8: 1, 1d, 12*d, ..., 1(k1)*d=RCOND = 9: random numbers chosen from (RCOND,1) = 10: random numbers with distribution IDIST (see DLARND.)
NN is INTEGER The order of the matrix.
NZ1NZ1 is INTEGER If abs(ITYPE) > 3, then the first NZ1 diagonal entries will be zero.
NZ2NZ2 is INTEGER If abs(ITYPE) > 3, then the last NZ2 diagonal entries will be zero.
ISIGNISIGN is INTEGER = 0: The sign of the diagonal and subdiagonal entries will be left unchanged. = 1: The diagonal and subdiagonal entries will have their sign changed at random. = 2: If ITYPE is 2 or 3, then the same as ISIGN=1. Otherwise, with probability 0.5, oddeven pairs of diagonal entries A(2*j1,2*j1), A(2*j,2*j) will be converted to a 2x2 block by pre and postmultiplying by distinct random orthogonal rotations. The remaining diagonal entries will have their sign changed at random.
AMAGNAMAGN is DOUBLE PRECISION The diagonal and subdiagonal entries will be multiplied by AMAGN.
RCONDRCOND is DOUBLE PRECISION If abs(ITYPE) > 4, then the smallest diagonal entry will be entry will be RCOND. RCOND must be between 0 and 1.
TRIANGTRIANG is DOUBLE PRECISION The entries above the diagonal will be random numbers with magnitude bounded by TRIANG (i.e., random numbers multiplied by TRIANG.)
IDISTIDIST is INTEGER Specifies the type of distribution to be used to generate a random matrix. = 1: UNIFORM( 0, 1 ) = 2: UNIFORM( 1, 1 ) = 3: NORMAL ( 0, 1 )
ISEEDISEED is INTEGER array, dimension (4) On entry ISEED specifies the seed of the random number generator. The values of ISEED are changed on exit, and can be used in the next call to DLATM4 to continue the same random number sequence. Note: ISEED(4) should be odd, for the random number generator used at present.
AA is DOUBLE PRECISION array, dimension (LDA, N) Array to be computed.
LDALDA is INTEGER Leading dimension of A. Must be at least 1 and at least N.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
logical function dlctes (double precision ZR, double precision ZI, double precision D)
DLCTES
Purpose:

DLCTES returns .TRUE. if the eigenvalue (ZR/D) + sqrt(1)*(ZI/D) is to be selected (specifically, in this subroutine, if the real part of the eigenvalue is negative), and otherwise it returns .FALSE.. It is used by the test routine DDRGES to test whether the driver routine DGGES successfully sorts eigenvalues.
Parameters:

ZR
ZR is DOUBLE PRECISION The numerator of the real part of a complex eigenvalue (ZR/D) + i*(ZI/D).
ZIZI is DOUBLE PRECISION The numerator of the imaginary part of a complex eigenvalue (ZR/D) + i*(ZI).
DD is DOUBLE PRECISION The denominator part of a complex eigenvalue (ZR/D) + i*(ZI/D).
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
logical function dlctsx (double precision AR, double precision AI, double precision BETA)
DLCTSX
Purpose:

This function is used to determine what eigenvalues will be selected. If this is part of the test driver DDRGSX, do not change the code UNLESS you are testing input examples and not using the builtin examples.
Parameters:

AR
AR is DOUBLE PRECISION The numerator of the real part of a complex eigenvalue (AR/BETA) + i*(AI/BETA).
AIAI is DOUBLE PRECISION The numerator of the imaginary part of a complex eigenvalue (AR/BETA) + i*(AI).
BETABETA is DOUBLE PRECISION The denominator part of a complex eigenvalue (AR/BETA) + i*(AI/BETA).
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dlsets (integer M, integer P, integer N, double precision, dimension( lda, * ) A, double precision, dimension( lda, * ) AF, integer LDA, double precision, dimension( ldb, * ) B, double precision, dimension( ldb, * ) BF, integer LDB, double precision, dimension( * ) C, double precision, dimension( * ) CF, double precision, dimension( * ) D, double precision, dimension( * ) DF, double precision, dimension( * ) X, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
DLSETS
Purpose:

DLSETS tests DGGLSE  a subroutine for solving linear equality constrained least square problem (LSE).
Parameters:

M
M is INTEGER The number of rows of the matrix A. M >= 0.
PP is INTEGER The number of rows of the matrix B. P >= 0.
NN is INTEGER The number of columns of the matrices A and B. N >= 0.
AA is DOUBLE PRECISION array, dimension (LDA,N) The MbyN matrix A.
AFAF is DOUBLE PRECISION array, dimension (LDA,N)
LDALDA is INTEGER The leading dimension of the arrays A, AF, Q and R. LDA >= max(M,N).
BB is DOUBLE PRECISION array, dimension (LDB,N) The PbyN matrix A.
BFBF is DOUBLE PRECISION array, dimension (LDB,N)
LDBLDB is INTEGER The leading dimension of the arrays B, BF, V and S. LDB >= max(P,N).
CC is DOUBLE PRECISION array, dimension( M ) the vector C in the LSE problem.
CFCF is DOUBLE PRECISION array, dimension( M )
DD is DOUBLE PRECISION array, dimension( P ) the vector D in the LSE problem.
DFDF is DOUBLE PRECISION array, dimension( P )
XX is DOUBLE PRECISION array, dimension( N ) solution vector X in the LSE problem.
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The dimension of the array WORK.
RWORKRWORK is DOUBLE PRECISION array, dimension (M)
RESULTRESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( A*x  c )/ norm(A)*norm(X)*EPS RESULT(2) = norm( B*x  d )/ norm(B)*norm(X)*EPS
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dort01 (character ROWCOL, integer M, integer N, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) WORK, integer LWORK, double precision RESID)
DORT01
Purpose:

DORT01 checks that the matrix U is orthogonal by computing the ratio RESID = norm( I  U*U' ) / ( n * EPS ), if ROWCOL = 'R', or RESID = norm( I  U'*U ) / ( m * EPS ), if ROWCOL = 'C'. Alternatively, if there isn't sufficient workspace to form I  U*U' or I  U'*U, the ratio is computed as RESID = abs( I  U*U' ) / ( n * EPS ), if ROWCOL = 'R', or RESID = abs( I  U'*U ) / ( m * EPS ), if ROWCOL = 'C'. where EPS is the machine precision. ROWCOL is used only if m = n; if m > n, ROWCOL is assumed to be 'C', and if m < n, ROWCOL is assumed to be 'R'.
Parameters:

ROWCOL
ROWCOL is CHARACTER Specifies whether the rows or columns of U should be checked for orthogonality. Used only if M = N. = 'R': Check for orthogonal rows of U = 'C': Check for orthogonal columns of U
MM is INTEGER The number of rows of the matrix U.
NN is INTEGER The number of columns of the matrix U.
UU is DOUBLE PRECISION array, dimension (LDU,N) The orthogonal matrix U. U is checked for orthogonal columns if m > n or if m = n and ROWCOL = 'C'. U is checked for orthogonal rows if m < n or if m = n and ROWCOL = 'R'.
LDULDU is INTEGER The leading dimension of the array U. LDU >= max(1,M).
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The length of the array WORK. For best performance, LWORK should be at least N*(N+1) if ROWCOL = 'C' or M*(M+1) if ROWCOL = 'R', but the test will be done even if LWORK is 0.
RESIDRESID is DOUBLE PRECISION RESID = norm( I  U * U' ) / ( n * EPS ), if ROWCOL = 'R', or RESID = norm( I  U' * U ) / ( m * EPS ), if ROWCOL = 'C'.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dort03 (character*( * ) RC, integer MU, integer MV, integer N, integer K, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( * ) WORK, integer LWORK, double precision RESULT, integer INFO)
DORT03
Purpose:

DORT03 compares two orthogonal matrices U and V to see if their corresponding rows or columns span the same spaces. The rows are checked if RC = 'R', and the columns are checked if RC = 'C'. RESULT is the maximum of  V*V'  I  / ( MV ulp ), if RC = 'R', or  V'*V  I  / ( MV ulp ), if RC = 'C', and the maximum over rows (or columns) 1 to K of  U(i)  S*V(i) / ( N ulp ) where S is +1 (chosen to minimize the expression), U(i) is the ith row (column) of U, and V(i) is the ith row (column) of V.
Parameters:

RC
RC is CHARACTER*1 If RC = 'R' the rows of U and V are to be compared. If RC = 'C' the columns of U and V are to be compared.
MUMU is INTEGER The number of rows of U if RC = 'R', and the number of columns if RC = 'C'. If MU = 0 DORT03 does nothing. MU must be at least zero.
MVMV is INTEGER The number of rows of V if RC = 'R', and the number of columns if RC = 'C'. If MV = 0 DORT03 does nothing. MV must be at least zero.
NN is INTEGER If RC = 'R', the number of columns in the matrices U and V, and if RC = 'C', the number of rows in U and V. If N = 0 DORT03 does nothing. N must be at least zero.
KK is INTEGER The number of rows or columns of U and V to compare. 0 <= K <= max(MU,MV).
UU is DOUBLE PRECISION array, dimension (LDU,N) The first matrix to compare. If RC = 'R', U is MU by N, and if RC = 'C', U is N by MU.
LDULDU is INTEGER The leading dimension of U. If RC = 'R', LDU >= max(1,MU), and if RC = 'C', LDU >= max(1,N).
VV is DOUBLE PRECISION array, dimension (LDV,N) The second matrix to compare. If RC = 'R', V is MV by N, and if RC = 'C', V is N by MV.
LDVLDV is INTEGER The leading dimension of V. If RC = 'R', LDV >= max(1,MV), and if RC = 'C', LDV >= max(1,N).
WORKWORK is DOUBLE PRECISION array, dimension (LWORK)
LWORKLWORK is INTEGER The length of the array WORK. For best performance, LWORK should be at least N*N if RC = 'C' or M*M if RC = 'R', but the tests will be done even if LWORK is 0.
RESULTRESULT is DOUBLE PRECISION The value computed by the test described above. RESULT is limited to 1/ulp to avoid overflow.
INFOINFO is INTEGER 0 indicates a successful exit k indicates the kth parameter had an illegal value
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dsbt21 (character UPLO, integer N, integer KA, integer KS, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)
DSBT21
Purpose:

DSBT21 generally checks a decomposition of the form A = U S U' where ' means transpose, A is symmetric banded, U is orthogonal, and S is diagonal (if KS=0) or symmetric tridiagonal (if KS=1). Specifically: RESULT(1) =  A  U S U'  / ( A n ulp ) *andC> RESULT(2) =  I  UU'  / ( n ulp )
Parameters:

UPLO
UPLO is CHARACTER If UPLO='U', the upper triangle of A and V will be used and the (strictly) lower triangle will not be referenced. If UPLO='L', the lower triangle of A and V will be used and the (strictly) upper triangle will not be referenced.
NN is INTEGER The size of the matrix. If it is zero, DSBT21 does nothing. It must be at least zero.
KAKA is INTEGER The bandwidth of the matrix A. It must be at least zero. If it is larger than N1, then max( 0, N1 ) will be used.
KSKS is INTEGER The bandwidth of the matrix S. It may only be zero or one. If zero, then S is diagonal, and E is not referenced. If one, then S is symmetric tridiagonal.
AA is DOUBLE PRECISION array, dimension (LDA, N) The original (unfactored) matrix. It is assumed to be symmetric, and only the upper (UPLO='U') or only the lower (UPLO='L') will be referenced.
LDALDA is INTEGER The leading dimension of A. It must be at least 1 and at least min( KA, N1 ).
DD is DOUBLE PRECISION array, dimension (N) The diagonal of the (symmetric tri) diagonal matrix S.
EE is DOUBLE PRECISION array, dimension (N1) The offdiagonal of the (symmetric tri) diagonal matrix S. E(1) is the (1,2) and (2,1) element, E(2) is the (2,3) and (3,2) element, etc. Not referenced if KS=0.
UU is DOUBLE PRECISION array, dimension (LDU, N) The orthogonal matrix in the decomposition, expressed as a dense matrix (i.e., not as a product of Householder transformations, Givens transformations, etc.)
LDULDU is INTEGER The leading dimension of U. LDU must be at least N and at least 1.
WORKWORK is DOUBLE PRECISION array, dimension (N**2+N)
RESULTRESULT is DOUBLE PRECISION array, dimension (2) The values computed by the two tests described above. The values are currently limited to 1/ulp, to avoid overflow.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dsgt01 (integer ITYPE, character UPLO, integer N, integer M, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( ldz, * ) Z, integer LDZ, double precision, dimension( * ) D, double precision, dimension( * ) WORK, double precision, dimension( * ) RESULT)
DSGT01
Purpose:

DDGT01 checks a decomposition of the form A Z = B Z D or A B Z = Z D or B A Z = Z D where A is a symmetric matrix, B is symmetric positive definite, Z is orthogonal, and D is diagonal. One of the following test ratios is computed: ITYPE = 1: RESULT(1) =  A Z  B Z D  / ( A Z n ulp ) ITYPE = 2: RESULT(1) =  A B Z  Z D  / ( A Z n ulp ) ITYPE = 3: RESULT(1) =  B A Z  Z D  / ( A Z n ulp )
Parameters:

ITYPE
ITYPE is INTEGER The form of the symmetric generalized eigenproblem. = 1: A*z = (lambda)*B*z = 2: A*B*z = (lambda)*z = 3: B*A*z = (lambda)*z
UPLOUPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the symmetric matrices A and B is stored. = 'U': Upper triangular = 'L': Lower triangular
NN is INTEGER The order of the matrix A. N >= 0.
MM is INTEGER The number of eigenvalues found. 0 <= M <= N.
AA is DOUBLE PRECISION array, dimension (LDA, N) The original symmetric matrix A.
LDALDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
BB is DOUBLE PRECISION array, dimension (LDB, N) The original symmetric positive definite matrix B.
LDBLDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
ZZ is DOUBLE PRECISION array, dimension (LDZ, M) The computed eigenvectors of the generalized eigenproblem.
LDZLDZ is INTEGER The leading dimension of the array Z. LDZ >= max(1,N).
DD is DOUBLE PRECISION array, dimension (M) The computed eigenvalues of the generalized eigenproblem.
WORKWORK is DOUBLE PRECISION array, dimension (N*N)
RESULTRESULT is DOUBLE PRECISION array, dimension (1) The test ratio as described above.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
logical function dslect (double precision ZR, double precision ZI)
DSLECT
Purpose:

DSLECT returns .TRUE. if the eigenvalue ZR+sqrt(1)*ZI is to be selected, and otherwise it returns .FALSE. It is used by DCHK41 to test if DGEES successfully sorts eigenvalues, and by DCHK43 to test if DGEESX successfully sorts eigenvalues. The common block /SSLCT/ controls how eigenvalues are selected. If SELOPT = 0, then DSLECT return .TRUE. when ZR is less than zero, and .FALSE. otherwise. If SELOPT is at least 1, DSLECT returns SELVAL(SELOPT) and adds 1 to SELOPT, cycling back to 1 at SELMAX.
Parameters:

ZR
ZR is DOUBLE PRECISION The real part of a complex eigenvalue ZR + i*ZI.
ZIZI is DOUBLE PRECISION The imaginary part of a complex eigenvalue ZR + i*ZI.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 June 2016
subroutine dspt21 (integer ITYPE, character UPLO, integer N, integer KBAND, double precision, dimension( * ) AP, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) VP, double precision, dimension( * ) TAU, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)
DSPT21
Purpose:

DSPT21 generally checks a decomposition of the form A = U S U' where ' means transpose, A is symmetric (stored in packed format), U is orthogonal, and S is diagonal (if KBAND=0) or symmetric tridiagonal (if KBAND=1). If ITYPE=1, then U is represented as a dense matrix, otherwise the U is expressed as a product of Householder transformations, whose vectors are stored in the array "V" and whose scaling constants are in "TAU"; we shall use the letter "V" to refer to the product of Householder transformations (which should be equal to U). Specifically, if ITYPE=1, then: RESULT(1) =  A  U S U'  / ( A n ulp ) *andC> RESULT(2) =  I  UU'  / ( n ulp ) If ITYPE=2, then: RESULT(1) =  A  V S V'  / ( A n ulp ) If ITYPE=3, then: RESULT(1) =  I  VU'  / ( n ulp ) Packed storage means that, for example, if UPLO='U', then the columns of the upper triangle of A are stored one after another, so that A(1,j+1) immediately follows A(j,j) in the array AP. Similarly, if UPLO='L', then the columns of the lower triangle of A are stored one after another in AP, so that A(j+1,j+1) immediately follows A(n,j) in the array AP. This means that A(i,j) is stored in: AP( i + j*(j1)/2 ) if UPLO='U' AP( i + (2*nj)*(j1)/2 ) if UPLO='L' The array VP bears the same relation to the matrix V that A does to AP. For ITYPE > 1, the transformation U is expressed as a product of Householder transformations: If UPLO='U', then V = H(n1)...H(1), where H(j) = I  tau(j) v(j) v(j)' and the first j1 elements of v(j) are stored in V(1:j1,j+1), (i.e., VP( j*(j+1)/2 + 1 : j*(j+1)/2 + j1 ) ), the jth element is 1, and the last nj elements are 0. If UPLO='L', then V = H(1)...H(n1), where H(j) = I  tau(j) v(j) v(j)' and the first j elements of v(j) are 0, the (j+1)st is 1, and the (j+2)nd through nth elements are stored in V(j+2:n,j) (i.e., in VP( (2*nj)*(j1)/2 + j+2 : (2*nj)*(j1)/2 + n ) .)
Parameters:

ITYPE
ITYPE is INTEGER Specifies the type of tests to be performed. 1: U expressed as a dense orthogonal matrix: RESULT(1) =  A  U S U'  / ( A n ulp ) *andC> RESULT(2) =  I  UU'  / ( n ulp ) 2: U expressed as a product V of Housholder transformations: RESULT(1) =  A  V S V'  / ( A n ulp ) 3: U expressed both as a dense orthogonal matrix and as a product of Housholder transformations: RESULT(1) =  I  VU'  / ( n ulp )
UPLOUPLO is CHARACTER If UPLO='U', AP and VP are considered to contain the upper triangle of A and V. If UPLO='L', AP and VP are considered to contain the lower triangle of A and V.
NN is INTEGER The size of the matrix. If it is zero, DSPT21 does nothing. It must be at least zero.
KBANDKBAND is INTEGER The bandwidth of the matrix. It may only be zero or one. If zero, then S is diagonal, and E is not referenced. If one, then S is symmetric tridiagonal.
APAP is DOUBLE PRECISION array, dimension (N*(N+1)/2) The original (unfactored) matrix. It is assumed to be symmetric, and contains the columns of just the upper triangle (UPLO='U') or only the lower triangle (UPLO='L'), packed one after another.
DD is DOUBLE PRECISION array, dimension (N) The diagonal of the (symmetric tri) diagonal matrix.
EE is DOUBLE PRECISION array, dimension (N1) The offdiagonal of the (symmetric tri) diagonal matrix. E(1) is the (1,2) and (2,1) element, E(2) is the (2,3) and (3,2) element, etc. Not referenced if KBAND=0.
UU is DOUBLE PRECISION array, dimension (LDU, N) If ITYPE=1 or 3, this contains the orthogonal matrix in the decomposition, expressed as a dense matrix. If ITYPE=2, then it is not referenced.
LDULDU is INTEGER The leading dimension of U. LDU must be at least N and at least 1.
VPVP is DOUBLE PRECISION array, dimension (N*(N+1)/2) If ITYPE=2 or 3, the columns of this array contain the Householder vectors used to describe the orthogonal matrix in the decomposition, as described in purpose. *NOTE* If ITYPE=2 or 3, V is modified and restored. The subdiagonal (if UPLO='L') or the superdiagonal (if UPLO='U') is set to one, and later reset to its original value, during the course of the calculation. If ITYPE=1, then it is neither referenced nor modified.
TAUTAU is DOUBLE PRECISION array, dimension (N) If ITYPE >= 2, then TAU(j) is the scalar factor of v(j) v(j)' in the Householder transformation H(j) of the product U = H(1)...H(n2) If ITYPE < 2, then TAU is not referenced.
WORKWORK is DOUBLE PRECISION array, dimension (N**2+N) Workspace.
RESULTRESULT is DOUBLE PRECISION array, dimension (2) The values computed by the two tests described above. The values are currently limited to 1/ulp, to avoid overflow. RESULT(1) is always modified. RESULT(2) is modified only if ITYPE=1.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dstech (integer N, double precision, dimension( * ) A, double precision, dimension( * ) B, double precision, dimension( * ) EIG, double precision TOL, double precision, dimension( * ) WORK, integer INFO)
DSTECH
Purpose:

Let T be the tridiagonal matrix with diagonal entries A(1) ,..., A(N) and offdiagonal entries B(1) ,..., B(N1)). DSTECH checks to see if EIG(1) ,..., EIG(N) are indeed accurate eigenvalues of T. It does this by expanding each EIG(I) into an interval [SVD(I)  EPS, SVD(I) + EPS], merging overlapping intervals if any, and using Sturm sequences to count and verify whether each resulting interval has the correct number of eigenvalues (using DSTECT). Here EPS = TOL*MAZHEPS*MAXEIG, where MACHEPS is the machine precision and MAXEIG is the absolute value of the largest eigenvalue. If each interval contains the correct number of eigenvalues, INFO = 0 is returned, otherwise INFO is the index of the first eigenvalue in the first bad interval.
Parameters:

N
N is INTEGER The dimension of the tridiagonal matrix T.
AA is DOUBLE PRECISION array, dimension (N) The diagonal entries of the tridiagonal matrix T.
BB is DOUBLE PRECISION array, dimension (N1) The offdiagonal entries of the tridiagonal matrix T.
EIGEIG is DOUBLE PRECISION array, dimension (N) The purported eigenvalues to be checked.
TOLTOL is DOUBLE PRECISION Error tolerance for checking, a multiple of the machine precision.
WORKWORK is DOUBLE PRECISION array, dimension (N)
INFOINFO is INTEGER 0 if the eigenvalues are all correct (to within 1 + TOL*MAZHEPS*MAXEIG) >0 if the interval containing the INFOth eigenvalue contains the incorrect number of eigenvalues.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dstect (integer N, double precision, dimension( * ) A, double precision, dimension( * ) B, double precision SHIFT, integer NUM)
DSTECT
Purpose:

DSTECT counts the number NUM of eigenvalues of a tridiagonal matrix T which are less than or equal to SHIFT. T has diagonal entries A(1), ... , A(N), and offdiagonal entries B(1), ..., B(N1). See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966
Parameters:

N
N is INTEGER The dimension of the tridiagonal matrix T.
AA is DOUBLE PRECISION array, dimension (N) The diagonal entries of the tridiagonal matrix T.
BB is DOUBLE PRECISION array, dimension (N1) The offdiagonal entries of the tridiagonal matrix T.
SHIFTSHIFT is DOUBLE PRECISION The shift, used as described under Purpose.
NUMNUM is INTEGER The number of eigenvalues of T less than or equal to SHIFT.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dstt21 (integer N, integer KBAND, double precision, dimension( * ) AD, double precision, dimension( * ) AE, double precision, dimension( * ) SD, double precision, dimension( * ) SE, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)
DSTT21
Purpose:

DSTT21 checks a decomposition of the form A = U S U' where ' means transpose, A is symmetric tridiagonal, U is orthogonal, and S is diagonal (if KBAND=0) or symmetric tridiagonal (if KBAND=1). Two tests are performed: RESULT(1) =  A  U S U'  / ( A n ulp ) RESULT(2) =  I  UU'  / ( n ulp )
Parameters:

N
N is INTEGER The size of the matrix. If it is zero, DSTT21 does nothing. It must be at least zero.
KBANDKBAND is INTEGER The bandwidth of the matrix S. It may only be zero or one. If zero, then S is diagonal, and SE is not referenced. If one, then S is symmetric tridiagonal.
ADAD is DOUBLE PRECISION array, dimension (N) The diagonal of the original (unfactored) matrix A. A is assumed to be symmetric tridiagonal.
AEAE is DOUBLE PRECISION array, dimension (N1) The offdiagonal of the original (unfactored) matrix A. A is assumed to be symmetric tridiagonal. AE(1) is the (1,2) and (2,1) element, AE(2) is the (2,3) and (3,2) element, etc.
SDSD is DOUBLE PRECISION array, dimension (N) The diagonal of the (symmetric tri) diagonal matrix S.
SESE is DOUBLE PRECISION array, dimension (N1) The offdiagonal of the (symmetric tri) diagonal matrix S. Not referenced if KBSND=0. If KBAND=1, then AE(1) is the (1,2) and (2,1) element, SE(2) is the (2,3) and (3,2) element, etc.
UU is DOUBLE PRECISION array, dimension (LDU, N) The orthogonal matrix in the decomposition.
LDULDU is INTEGER The leading dimension of U. LDU must be at least N.
WORKWORK is DOUBLE PRECISION array, dimension (N*(N+1))
RESULTRESULT is DOUBLE PRECISION array, dimension (2) The values computed by the two tests described above. The values are currently limited to 1/ulp, to avoid overflow. RESULT(1) is always modified.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dstt22 (integer N, integer M, integer KBAND, double precision, dimension( * ) AD, double precision, dimension( * ) AE, double precision, dimension( * ) SD, double precision, dimension( * ) SE, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldwork, * ) WORK, integer LDWORK, double precision, dimension( 2 ) RESULT)
DSTT22
Purpose:

DSTT22 checks a set of M eigenvalues and eigenvectors, A U = U S where A is symmetric tridiagonal, the columns of U are orthogonal, and S is diagonal (if KBAND=0) or symmetric tridiagonal (if KBAND=1). Two tests are performed: RESULT(1) =  U' A U  S  / ( A m ulp ) RESULT(2) =  I  U'U  / ( m ulp )
Parameters:

N
N is INTEGER The size of the matrix. If it is zero, DSTT22 does nothing. It must be at least zero.
MM is INTEGER The number of eigenpairs to check. If it is zero, DSTT22 does nothing. It must be at least zero.
KBANDKBAND is INTEGER The bandwidth of the matrix S. It may only be zero or one. If zero, then S is diagonal, and SE is not referenced. If one, then S is symmetric tridiagonal.
ADAD is DOUBLE PRECISION array, dimension (N) The diagonal of the original (unfactored) matrix A. A is assumed to be symmetric tridiagonal.
AEAE is DOUBLE PRECISION array, dimension (N) The offdiagonal of the original (unfactored) matrix A. A is assumed to be symmetric tridiagonal. AE(1) is ignored, AE(2) is the (1,2) and (2,1) element, etc.
SDSD is DOUBLE PRECISION array, dimension (N) The diagonal of the (symmetric tri) diagonal matrix S.
SESE is DOUBLE PRECISION array, dimension (N) The offdiagonal of the (symmetric tri) diagonal matrix S. Not referenced if KBSND=0. If KBAND=1, then AE(1) is ignored, SE(2) is the (1,2) and (2,1) element, etc.
UU is DOUBLE PRECISION array, dimension (LDU, N) The orthogonal matrix in the decomposition.
LDULDU is INTEGER The leading dimension of U. LDU must be at least N.
WORKWORK is DOUBLE PRECISION array, dimension (LDWORK, M+1)
LDWORKLDWORK is INTEGER The leading dimension of WORK. LDWORK must be at least max(1,M).
RESULTRESULT is DOUBLE PRECISION array, dimension (2) The values computed by the two tests described above. The values are currently limited to 1/ulp, to avoid overflow.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dsvdch (integer N, double precision, dimension( * ) S, double precision, dimension( * ) E, double precision, dimension( * ) SVD, double precision TOL, integer INFO)
DSVDCH
Purpose:

DSVDCH checks to see if SVD(1) ,..., SVD(N) are accurate singular values of the bidiagonal matrix B with diagonal entries S(1) ,..., S(N) and superdiagonal entries E(1) ,..., E(N1)). It does this by expanding each SVD(I) into an interval [SVD(I) * (1EPS) , SVD(I) * (1+EPS)], merging overlapping intervals if any, and using Sturm sequences to count and verify whether each resulting interval has the correct number of singular values (using DSVDCT). Here EPS=TOL*MAX(N/10,1)*MAZHEP, where MACHEP is the machine precision. The routine assumes the singular values are sorted with SVD(1) the largest and SVD(N) smallest. If each interval contains the correct number of singular values, INFO = 0 is returned, otherwise INFO is the index of the first singular value in the first bad interval.
Parameters:

N
N is INTEGER The dimension of the bidiagonal matrix B.
SS is DOUBLE PRECISION array, dimension (N) The diagonal entries of the bidiagonal matrix B.
EE is DOUBLE PRECISION array, dimension (N1) The superdiagonal entries of the bidiagonal matrix B.
SVDSVD is DOUBLE PRECISION array, dimension (N) The computed singular values to be checked.
TOLTOL is DOUBLE PRECISION Error tolerance for checking, a multiplier of the machine precision.
INFOINFO is INTEGER =0 if the singular values are all correct (to within 1 + TOL*MAZHEPS) >0 if the interval containing the INFOth singular value contains the incorrect number of singular values.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dsvdct (integer N, double precision, dimension( * ) S, double precision, dimension( * ) E, double precision SHIFT, integer NUM)
DSVDCT
Purpose:

DSVDCT counts the number NUM of eigenvalues of a 2*N by 2*N tridiagonal matrix T which are less than or equal to SHIFT. T is formed by putting zeros on the diagonal and making the offdiagonals equal to S(1), E(1), S(2), E(2), ... , E(N1), S(N). If SHIFT is positive, NUM is equal to N plus the number of singular values of a bidiagonal matrix B less than or equal to SHIFT. Here B has diagonal entries S(1), ..., S(N) and superdiagonal entries E(1), ... E(N1). If SHIFT is negative, NUM is equal to the number of singular values of B greater than or equal to SHIFT. See W. Kahan "Accurate Eigenvalues of a Symmetric Tridiagonal Matrix", Report CS41, Computer Science Dept., Stanford University, July 21, 1966
Parameters:

N
N is INTEGER The dimension of the bidiagonal matrix B.
SS is DOUBLE PRECISION array, dimension (N) The diagonal entries of the bidiagonal matrix B.
EE is DOUBLE PRECISION array of dimension (N1) The superdiagonal entries of the bidiagonal matrix B.
SHIFTSHIFT is DOUBLE PRECISION The shift, used as described under Purpose.
NUMNUM is INTEGER The number of eigenvalues of T less than or equal to SHIFT.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
double precision function dsxt1 (integer IJOB, double precision, dimension( * ) D1, integer N1, double precision, dimension( * ) D2, integer N2, double precision ABSTOL, double precision ULP, double precision UNFL)
DSXT1
Purpose:

DSXT1 computes the difference between a set of eigenvalues. The result is returned as the function value. IJOB = 1: Computes max { min  D1(i)D2(j)  } i j IJOB = 2: Computes max { min  D1(i)D2(j)  / i j ( ABSTOL + D1(i)*ULP ) }
Parameters:

IJOB
IJOB is INTEGER Specifies the type of tests to be performed. (See above.)
D1D1 is DOUBLE PRECISION array, dimension (N1) The first array. D1 should be in increasing order, i.e., D1(j) <= D1(j+1).
N1N1 is INTEGER The length of D1.
D2D2 is DOUBLE PRECISION array, dimension (N2) The second array. D2 should be in increasing order, i.e., D2(j) <= D2(j+1).
N2N2 is INTEGER The length of D2.
ABSTOLABSTOL is DOUBLE PRECISION The absolute tolerance, used as a measure of the error.
ULPULP is DOUBLE PRECISION Machine precision.
UNFLUNFL is DOUBLE PRECISION The smallest positive number whose reciprocal does not overflow.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dsyt21 (integer ITYPE, character UPLO, integer N, integer KBAND, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( * ) TAU, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)
DSYT21
Purpose:

DSYT21 generally checks a decomposition of the form A = U S U' where ' means transpose, A is symmetric, U is orthogonal, and S is diagonal (if KBAND=0) or symmetric tridiagonal (if KBAND=1). If ITYPE=1, then U is represented as a dense matrix; otherwise U is expressed as a product of Householder transformations, whose vectors are stored in the array "V" and whose scaling constants are in "TAU". We shall use the letter "V" to refer to the product of Householder transformations (which should be equal to U). Specifically, if ITYPE=1, then: RESULT(1) =  A  U S U'  / ( A n ulp ) *andC> RESULT(2) =  I  UU'  / ( n ulp ) If ITYPE=2, then: RESULT(1) =  A  V S V'  / ( A n ulp ) If ITYPE=3, then: RESULT(1) =  I  VU'  / ( n ulp ) For ITYPE > 1, the transformation U is expressed as a product V = H(1)...H(n2), where H(j) = I  tau(j) v(j) v(j)' and each vector v(j) has its first j elements 0 and the remaining nj elements stored in V(j+1:n,j).
Parameters:

ITYPE
ITYPE is INTEGER Specifies the type of tests to be performed. 1: U expressed as a dense orthogonal matrix: RESULT(1) =  A  U S U'  / ( A n ulp ) *andC> RESULT(2) =  I  UU'  / ( n ulp ) 2: U expressed as a product V of Housholder transformations: RESULT(1) =  A  V S V'  / ( A n ulp ) 3: U expressed both as a dense orthogonal matrix and as a product of Housholder transformations: RESULT(1) =  I  VU'  / ( n ulp )
UPLOUPLO is CHARACTER If UPLO='U', the upper triangle of A and V will be used and the (strictly) lower triangle will not be referenced. If UPLO='L', the lower triangle of A and V will be used and the (strictly) upper triangle will not be referenced.
NN is INTEGER The size of the matrix. If it is zero, DSYT21 does nothing. It must be at least zero.
KBANDKBAND is INTEGER The bandwidth of the matrix. It may only be zero or one. If zero, then S is diagonal, and E is not referenced. If one, then S is symmetric tridiagonal.
AA is DOUBLE PRECISION array, dimension (LDA, N) The original (unfactored) matrix. It is assumed to be symmetric, and only the upper (UPLO='U') or only the lower (UPLO='L') will be referenced.
LDALDA is INTEGER The leading dimension of A. It must be at least 1 and at least N.
DD is DOUBLE PRECISION array, dimension (N) The diagonal of the (symmetric tri) diagonal matrix.
EE is DOUBLE PRECISION array, dimension (N1) The offdiagonal of the (symmetric tri) diagonal matrix. E(1) is the (1,2) and (2,1) element, E(2) is the (2,3) and (3,2) element, etc. Not referenced if KBAND=0.
UU is DOUBLE PRECISION array, dimension (LDU, N) If ITYPE=1 or 3, this contains the orthogonal matrix in the decomposition, expressed as a dense matrix. If ITYPE=2, then it is not referenced.
LDULDU is INTEGER The leading dimension of U. LDU must be at least N and at least 1.
VV is DOUBLE PRECISION array, dimension (LDV, N) If ITYPE=2 or 3, the columns of this array contain the Householder vectors used to describe the orthogonal matrix in the decomposition. If UPLO='L', then the vectors are in the lower triangle, if UPLO='U', then in the upper triangle. *NOTE* If ITYPE=2 or 3, V is modified and restored. The subdiagonal (if UPLO='L') or the superdiagonal (if UPLO='U') is set to one, and later reset to its original value, during the course of the calculation. If ITYPE=1, then it is neither referenced nor modified.
LDVLDV is INTEGER The leading dimension of V. LDV must be at least N and at least 1.
TAUTAU is DOUBLE PRECISION array, dimension (N) If ITYPE >= 2, then TAU(j) is the scalar factor of v(j) v(j)' in the Householder transformation H(j) of the product U = H(1)...H(n2) If ITYPE < 2, then TAU is not referenced.
WORKWORK is DOUBLE PRECISION array, dimension (2*N**2)
RESULTRESULT is DOUBLE PRECISION array, dimension (2) The values computed by the two tests described above. The values are currently limited to 1/ulp, to avoid overflow. RESULT(1) is always modified. RESULT(2) is modified only if ITYPE=1.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine dsyt22 (integer ITYPE, character UPLO, integer N, integer M, integer KBAND, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( * ) TAU, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)
DSYT22
Purpose:

DSYT22 generally checks a decomposition of the form A U = U S where A is symmetric, the columns of U are orthonormal, and S is diagonal (if KBAND=0) or symmetric tridiagonal (if KBAND=1). If ITYPE=1, then U is represented as a dense matrix, otherwise the U is expressed as a product of Householder transformations, whose vectors are stored in the array "V" and whose scaling constants are in "TAU"; we shall use the letter "V" to refer to the product of Householder transformations (which should be equal to U). Specifically, if ITYPE=1, then: RESULT(1) =  U' A U  S  / ( A m ulp ) *andC> RESULT(2) =  I  U'U  / ( m ulp )
ITYPE INTEGER Specifies the type of tests to be performed. 1: U expressed as a dense orthogonal matrix: RESULT(1) =  A  U S U'  / ( A n ulp ) *andC> RESULT(2) =  I  UU'  / ( n ulp ) UPLO CHARACTER If UPLO='U', the upper triangle of A will be used and the (strictly) lower triangle will not be referenced. If UPLO='L', the lower triangle of A will be used and the (strictly) upper triangle will not be referenced. Not modified. N INTEGER The size of the matrix. If it is zero, DSYT22 does nothing. It must be at least zero. Not modified. M INTEGER The number of columns of U. If it is zero, DSYT22 does nothing. It must be at least zero. Not modified. KBAND INTEGER The bandwidth of the matrix. It may only be zero or one. If zero, then S is diagonal, and E is not referenced. If one, then S is symmetric tridiagonal. Not modified. A DOUBLE PRECISION array, dimension (LDA , N) The original (unfactored) matrix. It is assumed to be symmetric, and only the upper (UPLO='U') or only the lower (UPLO='L') will be referenced. Not modified. LDA INTEGER The leading dimension of A. It must be at least 1 and at least N. Not modified. D DOUBLE PRECISION array, dimension (N) The diagonal of the (symmetric tri) diagonal matrix. Not modified. E DOUBLE PRECISION array, dimension (N) The offdiagonal of the (symmetric tri) diagonal matrix. E(1) is ignored, E(2) is the (1,2) and (2,1) element, etc. Not referenced if KBAND=0. Not modified. U DOUBLE PRECISION array, dimension (LDU, N) If ITYPE=1 or 3, this contains the orthogonal matrix in the decomposition, expressed as a dense matrix. If ITYPE=2, then it is not referenced. Not modified. LDU INTEGER The leading dimension of U. LDU must be at least N and at least 1. Not modified. V DOUBLE PRECISION array, dimension (LDV, N) If ITYPE=2 or 3, the lower triangle of this array contains the Householder vectors used to describe the orthogonal matrix in the decomposition. If ITYPE=1, then it is not referenced. Not modified. LDV INTEGER The leading dimension of V. LDV must be at least N and at least 1. Not modified. TAU DOUBLE PRECISION array, dimension (N) If ITYPE >= 2, then TAU(j) is the scalar factor of v(j) v(j)' in the Householder transformation H(j) of the product U = H(1)...H(n2) If ITYPE < 2, then TAU is not referenced. Not modified. WORK DOUBLE PRECISION array, dimension (2*N**2) Workspace. Modified. RESULT DOUBLE PRECISION array, dimension (2) The values computed by the two tests described above. The values are currently limited to 1/ulp, to avoid overflow. RESULT(1) is always modified. RESULT(2) is modified only if LDU is at least N. Modified.
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine sbdt04 (character UPLO, integer N, real, dimension( * ) D, real, dimension( * ) E, real, dimension( * ) S, integer NS, real, dimension( ldu, * ) U, integer LDU, real, dimension( ldvt, * ) VT, integer LDVT, real, dimension( * ) WORK, real RESID)
Purpose:
SBDT04 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.
The test ratio to test the singular value decomposition is RESID = norm( S  U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.
Parameters:

UPLO
UPLO is CHARACTER*1 Specifies whether the matrix B is upper or lower bidiagonal. = 'U': Upper bidiagonal = 'L': Lower bidiagonal
NN is INTEGER The order of the matrix B.
DD is REAL array, dimension (N) The n diagonal elements of the bidiagonal matrix B.
EE is REAL array, dimension (N1) The (n1) superdiagonal elements of the bidiagonal matrix B if UPLO = 'U', or the (n1) subdiagonal elements of B if UPLO = 'L'.
SS is REAL array, dimension (NS) The singular values from the (partial) SVD of B, sorted in decreasing order.
NSNS is INTEGER The number of singular values/vectors from the (partial) SVD of B.
UU is REAL array, dimension (LDU,NS) The n by ns orthogonal matrix U in S = U' * B * V.
LDULDU is INTEGER The leading dimension of the array U. LDU >= max(1,N)
VTVT is REAL array, dimension (LDVT,N) The n by ns orthogonal matrix V in S = U' * B * V.
LDVTLDVT is INTEGER The leading dimension of the array VT.
WORKWORK is REAL array, dimension (2*N)
RESIDRESID is REAL The test ratio: norm(S  U' * B * V) / ( n * norm(B) * EPS )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine sbdt05 (integer M, integer N, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) S, integer NS, real, dimension( ldu, * ) U, integer LDU, real, dimension( ldvt, * ) VT, integer LDVT, real, dimension( * ) WORK, real RESID)
Purpose:
SBDT05 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.
The test ratio to test the singular value decomposition is RESID = norm( S  U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.
Parameters:

M
M is INTEGER The number of rows of the matrices A and U.
NN is INTEGER The number of columns of the matrices A and VT.
AA is REAL array, dimension (LDA,N) The m by n matrix A.
aram[in] LDA leading dimension of the array A. LDA >= max(1,M).
SS is REAL array, dimension (NS) The singular values from the (partial) SVD of B, sorted in decreasing order.
NSNS is INTEGER The number of singular values/vectors from the (partial) SVD of B.
UU is REAL array, dimension (LDU,NS) The n by ns orthogonal matrix U in S = U' * B * V.
LDULDU is INTEGER The leading dimension of the array U. LDU >= max(1,N)
VTVT is REAL array, dimension (LDVT,N) The n by ns orthogonal matrix V in S = U' * B * V.
LDVTLDVT is INTEGER The leading dimension of the array VT.
WORKWORK is REAL array, dimension (M,N)
RESIDRESID is REAL The test ratio: norm(S  U' * A * V) / ( n * norm(A) * EPS )
Author:

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
 November 2011
subroutine zbdt05 (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) S, integer NS, complex*16, dimension( * ) U, integer LDU, complex*16, dimension( ldvt, * ) VT, integer LDVT, complex*16, dimension( * ) WORK, double precision RESID)
Purpose:
ZBDT05 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.
The test ratio to test the singular value decomposition is RESID = norm( S  U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.
Parameters:

M
M is INTEGER The number of rows of the matrices A and U.
NN is INTEGER The number of columns of the matrices A and VT.
AA is COMPLEX*16 array, dimension (LDA,N) The m by n matrix A.
aram[in] LDA leading dimension of the array A. LDA >= max(1,M).
SS is DOUBLE PRECISION array, dimension (NS) The singular values from the (partial) SVD of B, sorted in decreasing order.
NSNS is INTEGER The number of singular values/vectors from the (partial) SVD of B.
UU is COMPLEX*16 array, dimension (LDU,NS) The n by ns orthogonal matrix U in S = U' * B * V.
LDULDU is INTEGER The leading dimension of the array U. LDU >= max(1,N)
VTVT is COMPLEX*16 array, dimension (LDVT,N) The n by ns orthogonal matrix V in S = U' * B * V.
LDVTLDVT is INTEGER The leading dimension of the array VT.
WORKWORK is COMPLEX*16 array, dimension (M,N)
RESIDRESID is DOUBLE PRECISION The test ratio: norm(S  U' * A * V) / ( n * norm(A) * EPS )
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.