Provided by: liblapack-doc-man_3.6.0-2ubuntu2_all 
NAME
complex16_eig - complex16
Functions
subroutine zbdt01 (M, N, KD, A, LDA, Q, LDQ, D, E, PT, LDPT, WORK, RWORK, RESID)
ZBDT01
subroutine zbdt02 (M, N, B, LDB, C, LDC, U, LDU, WORK, RWORK, RESID)
ZBDT02
subroutine zbdt03 (UPLO, N, KD, D, E, U, LDU, S, VT, LDVT, WORK, RESID)
ZBDT03
subroutine zchkbb (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, RWORK,
RESULT, INFO)
ZCHKBB
subroutine zchkbd (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, RWORK, NOUT, INFO)
ZCHKBD
subroutine zchkbk (NIN, NOUT)
ZCHKBK
subroutine zchkbl (NIN, NOUT)
ZCHKBL
subroutine zchkec (THRESH, TSTERR, NIN, NOUT)
ZCHKEC
program zchkee
ZCHKEE
subroutine zchkgg (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, TSTDIF, THRSHN, NOUNIT, A,
LDA, B, H, T, S1, S2, P1, P2, U, LDU, V, Q, Z, ALPHA1, BETA1, ALPHA3, BETA3, EVECTL,
EVECTR, WORK, LWORK, RWORK, LLWORK, RESULT, INFO)
ZCHKGG
subroutine zchkgk (NIN, NOUT)
ZCHKGK
subroutine zchkgl (NIN, NOUT)
ZCHKGL
subroutine zchkhb (NSIZES, NN, NWDTHS, KK, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA,
SD, SE, U, LDU, WORK, LWORK, RWORK, RESULT, INFO)
ZCHKHB
subroutine zchkhs (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, H, T1, T2,
U, LDU, Z, UZ, W1, W3, EVECTL, EVECTR, EVECTY, EVECTX, UU, TAU, WORK, NWORK, RWORK,
IWORK, SELECT, RESULT, INFO)
ZCHKHS
subroutine zchkst (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, RWORK,
LRWORK, IWORK, LIWORK, RESULT, INFO)
ZCHKST
subroutine zckcsd (NM, MVAL, PVAL, QVAL, NMATS, ISEED, THRESH, MMAX, X, XF, U1, U2, V1T,
V2T, THETA, IWORK, WORK, RWORK, NIN, NOUT, INFO)
ZCKCSD
subroutine zckglm (NN, NVAL, MVAL, PVAL, NMATS, ISEED, THRESH, NMAX, A, AF, B, BF, X,
WORK, RWORK, NIN, NOUT, INFO)
ZCKGLM
subroutine zckgqr (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)
ZCKGQR
subroutine zckgsv (NM, MVAL, PVAL, NVAL, NMATS, ISEED, THRESH, NMAX, A, AF, B, BF, U, V,
Q, ALPHA, BETA, R, IWORK, WORK, RWORK, NIN, NOUT, INFO)
ZCKGSV
subroutine zcklse (NN, MVAL, PVAL, NVAL, NMATS, ISEED, THRESH, NMAX, A, AF, B, BF, X,
WORK, RWORK, NIN, NOUT, INFO)
ZCKLSE
subroutine zcsdts (M, P, Q, X, XF, LDX, U1, LDU1, U2, LDU2, V1T, LDV1T, V2T, LDV2T, THETA,
IWORK, WORK, LWORK, RWORK, RESULT)
ZCSDTS
subroutine zdrges (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q,
LDQ, Z, ALPHA, BETA, WORK, LWORK, RWORK, RESULT, BWORK, INFO)
ZDRGES
subroutine zdrges3 (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q,
LDQ, Z, ALPHA, BETA, WORK, LWORK, RWORK, RESULT, BWORK, INFO)
ZDRGES3
subroutine zdrgev (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q,
LDQ, Z, QE, LDQE, ALPHA, BETA, ALPHA1, BETA1, WORK, LWORK, RWORK, RESULT, INFO)
ZDRGEV
subroutine zdrgev3 (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q,
LDQ, Z, QE, LDQE, ALPHA, BETA, ALPHA1, BETA1, WORK, LWORK, RWORK, RESULT, INFO)
ZDRGEV3
subroutine zdrgsx (NSIZE, NCMAX, THRESH, NIN, NOUT, A, LDA, B, AI, BI, Z, Q, ALPHA, BETA,
C, LDC, S, WORK, LWORK, RWORK, IWORK, LIWORK, BWORK, INFO)
ZDRGSX
subroutine zdrgvx (NSIZE, THRESH, NIN, NOUT, A, LDA, B, AI, BI, ALPHA, BETA, VL, VR, ILO,
IHI, LSCALE, RSCALE, S, DTRU, DIF, DIFTRU, WORK, LWORK, RWORK, IWORK, LIWORK, RESULT,
BWORK, INFO)
ZDRGVX
subroutine zdrvbd (NSIZES, MM, NN, NTYPES, DOTYPE, ISEED, THRESH, A, LDA, U, LDU, VT,
LDVT, ASAV, USAV, VTSAV, S, SSAV, E, WORK, LWORK, RWORK, IWORK, NOUNIT, INFO)
ZDRVBD
subroutine zdrves (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, H, HT, W,
WT, VS, LDVS, RESULT, WORK, NWORK, RWORK, IWORK, BWORK, INFO)
ZDRVES
subroutine zdrvev (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, H, W, W1,
VL, LDVL, VR, LDVR, LRE, LDLRE, RESULT, WORK, NWORK, RWORK, IWORK, INFO)
ZDRVEV
subroutine zdrvsg (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, LDB, D,
Z, LDZ, AB, BB, AP, BP, WORK, NWORK, RWORK, LRWORK, IWORK, LIWORK, RESULT, INFO)
ZDRVSG
subroutine zdrvst (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, D1, D2, D3,
WA1, WA2, WA3, U, LDU, V, TAU, Z, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, RESULT,
INFO)
ZDRVST
subroutine zdrvsx (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NIUNIT, NOUNIT, A, LDA, H,
HT, W, WT, WTMP, VS, LDVS, VS1, RESULT, WORK, LWORK, RWORK, BWORK, INFO)
ZDRVSX
subroutine zdrvvx (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NIUNIT, NOUNIT, A, LDA, H,
W, W1, VL, LDVL, VR, LDVR, LRE, LDLRE, RCONDV, RCNDV1, RCDVIN, RCONDE, RCNDE1, RCDEIN,
SCALE, SCALE1, RESULT, WORK, NWORK, RWORK, INFO)
ZDRVVX
subroutine zerrbd (PATH, NUNIT)
ZERRBD
subroutine zerrec (PATH, NUNIT)
ZERREC
subroutine zerred (PATH, NUNIT)
ZERRED
subroutine zerrgg (PATH, NUNIT)
ZERRGG
subroutine zerrhs (PATH, NUNIT)
ZERRHS
subroutine zerrst (PATH, NUNIT)
ZERRST
subroutine zget02 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZGET02
subroutine zget10 (M, N, A, LDA, B, LDB, WORK, RWORK, RESULT)
ZGET10
subroutine zget22 (TRANSA, TRANSE, TRANSW, N, A, LDA, E, LDE, W, WORK, RWORK, RESULT)
ZGET22
subroutine zget23 (COMP, ISRT, BALANC, JTYPE, THRESH, ISEED, NOUNIT, N, A, LDA, H, W, W1,
VL, LDVL, VR, LDVR, LRE, LDLRE, RCONDV, RCNDV1, RCDVIN, RCONDE, RCNDE1, RCDEIN, SCALE,
SCALE1, RESULT, WORK, LWORK, RWORK, INFO)
ZGET23
subroutine zget24 (COMP, JTYPE, THRESH, ISEED, NOUNIT, N, A, LDA, H, HT, W, WT, WTMP, VS,
LDVS, VS1, RCDEIN, RCDVIN, NSLCT, ISLCT, ISRT, RESULT, WORK, LWORK, RWORK, BWORK,
INFO)
ZGET24
subroutine zget35 (RMAX, LMAX, NINFO, KNT, NIN)
ZGET35
subroutine zget36 (RMAX, LMAX, NINFO, KNT, NIN)
ZGET36
subroutine zget37 (RMAX, LMAX, NINFO, KNT, NIN)
ZGET37
subroutine zget38 (RMAX, LMAX, NINFO, KNT, NIN)
ZGET38
subroutine zget51 (ITYPE, N, A, LDA, B, LDB, U, LDU, V, LDV, WORK, RWORK, RESULT)
ZGET51
subroutine zget52 (LEFT, N, A, LDA, B, LDB, E, LDE, ALPHA, BETA, WORK, RWORK, RESULT)
ZGET52
subroutine zget54 (N, A, LDA, B, LDB, S, LDS, T, LDT, U, LDU, V, LDV, WORK, RESULT)
ZGET54
subroutine zglmts (N, M, P, A, AF, LDA, B, BF, LDB, D, DF, X, U, WORK, LWORK, RWORK,
RESULT)
ZGLMTS
subroutine zgqrts (N, M, P, A, AF, Q, R, LDA, TAUA, B, BF, Z, T, BWK, LDB, TAUB, WORK,
LWORK, RWORK, RESULT)
ZGQRTS
subroutine zgrqts (M, P, N, A, AF, Q, R, LDA, TAUA, B, BF, Z, T, BWK, LDB, TAUB, WORK,
LWORK, RWORK, RESULT)
ZGRQTS
subroutine zgsvts3 (M, P, N, A, AF, LDA, B, BF, LDB, U, LDU, V, LDV, Q, LDQ, ALPHA, BETA,
R, LDR, IWORK, WORK, LWORK, RWORK, RESULT)
ZGSVTS3
subroutine zhbt21 (UPLO, N, KA, KS, A, LDA, D, E, U, LDU, WORK, RWORK, RESULT)
ZHBT21
subroutine zhet21 (ITYPE, UPLO, N, KBAND, A, LDA, D, E, U, LDU, V, LDV, TAU, WORK, RWORK,
RESULT)
ZHET21
subroutine zhet22 (ITYPE, UPLO, N, M, KBAND, A, LDA, D, E, U, LDU, V, LDV, TAU, WORK,
RWORK, RESULT)
ZHET22
subroutine zhpt21 (ITYPE, UPLO, N, KBAND, AP, D, E, U, LDU, VP, TAU, WORK, RWORK, RESULT)
ZHPT21
subroutine zhst01 (N, ILO, IHI, A, LDA, H, LDH, Q, LDQ, WORK, LWORK, RWORK, RESULT)
ZHST01
subroutine zlarfy (UPLO, N, V, INCV, TAU, C, LDC, WORK)
ZLARFY
subroutine zlarhs (PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB,
ISEED, INFO)
ZLARHS
subroutine zlatm4 (ITYPE, N, NZ1, NZ2, RSIGN, AMAGN, RCOND, TRIANG, IDIST, ISEED, A, LDA)
ZLATM4
logical function zlctes (Z, D)
ZLCTES
logical function zlctsx (ALPHA, BETA)
ZLCTSX
subroutine zlsets (M, P, N, A, AF, LDA, B, BF, LDB, C, CF, D, DF, X, WORK, LWORK, RWORK,
RESULT)
ZLSETS
subroutine zsbmv (UPLO, N, K, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
ZSBMV
subroutine zsgt01 (ITYPE, UPLO, N, M, A, LDA, B, LDB, Z, LDZ, D, WORK, RWORK, RESULT)
ZSGT01
logical function zslect (Z)
ZSLECT
subroutine zstt21 (N, KBAND, AD, AE, SD, SE, U, LDU, WORK, RWORK, RESULT)
ZSTT21
subroutine zstt22 (N, M, KBAND, AD, AE, SD, SE, U, LDU, WORK, LDWORK, RWORK, RESULT)
ZSTT22
subroutine zunt01 (ROWCOL, M, N, U, LDU, WORK, LWORK, RWORK, RESID)
ZUNT01
subroutine zunt03 (RC, MU, MV, N, K, U, LDU, V, LDV, WORK, LWORK, RWORK, RESULT, INFO)
ZUNT03
Detailed Description
This is the group of complex16 LAPACK TESTING EIG routines.
Function Documentation
subroutine zbdt01 (integer M, integer N, integer KD, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( ldq, * ) Q, integer LDQ, double precision, dimension(
* ) D, double precision, dimension( * ) E, complex*16, dimension( ldpt, * ) PT, integer
LDPT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, double
precision RESID)
ZBDT01
Purpose:
ZBDT01 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 unitary
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.
N
N is INTEGER
The number of columns of the matrices A and P'.
KD
KD 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.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m by n matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,M).
Q
Q is COMPLEX*16 array, dimension (LDQ,N)
The m by min(m,n) unitary matrix Q in the reduction
A = Q * B * P'.
LDQ
LDQ is INTEGER
The leading dimension of the array Q. LDQ >= max(1,M).
D
D is DOUBLE PRECISION array, dimension (min(M,N))
The diagonal elements of the bidiagonal matrix B.
E
E 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.
PT
PT is COMPLEX*16 array, dimension (LDPT,N)
The min(m,n) by n unitary matrix P' in the reduction
A = Q * B * P'.
LDPT
LDPT is INTEGER
The leading dimension of the array PT.
LDPT >= max(1,min(M,N)).
WORK
WORK is COMPLEX*16 array, dimension (M+N)
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESID
RESID 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 zbdt02 (integer M, integer N, complex*16, dimension( ldb, * ) B, integer LDB,
complex*16, dimension( ldc, * ) C, integer LDC, complex*16, dimension( ldu, * ) U, integer
LDU, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, double
precision RESID)
ZBDT02
Purpose:
ZBDT02 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.
N
N is INTEGER
The number of columns of the matrices B and C.
B
B is COMPLEX*16 array, dimension (LDB,N)
The m by n matrix B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,M).
C
C is COMPLEX*16 array, dimension (LDC,N)
The m by n matrix C, assumed to contain U' * B.
LDC
LDC is INTEGER
The leading dimension of the array C. LDC >= max(1,M).
U
U is COMPLEX*16 array, dimension (LDU,M)
The m by m orthogonal matrix U.
LDU
LDU is INTEGER
The leading dimension of the array U. LDU >= max(1,M).
WORK
WORK is COMPLEX*16 array, dimension (M)
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESID
RESID 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 zbdt03 (character UPLO, integer N, integer KD, double precision, dimension( * ) D,
double precision, dimension( * ) E, complex*16, dimension( ldu, * ) U, integer LDU, double
precision, dimension( * ) S, complex*16, dimension( ldvt, * ) VT, integer LDVT,
complex*16, dimension( * ) WORK, double precision RESID)
ZBDT03
Purpose:
ZBDT03 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
N
N is INTEGER
The order of the matrix B.
KD
KD 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.
D
D is DOUBLE PRECISION array, dimension (N)
The n diagonal elements of the bidiagonal matrix B.
E
E is DOUBLE PRECISION array, dimension (N-1)
The (n-1) superdiagonal elements of the bidiagonal matrix B
if UPLO = 'U', or the (n-1) subdiagonal elements of B if
UPLO = 'L'.
U
U is COMPLEX*16 array, dimension (LDU,N)
The n by n orthogonal matrix U in the reduction B = U'*A*P.
LDU
LDU is INTEGER
The leading dimension of the array U. LDU >= max(1,N)
S
S is DOUBLE PRECISION array, dimension (N)
The singular values from the SVD of B, sorted in decreasing
order.
VT
VT is COMPLEX*16 array, dimension (LDVT,N)
The n by n orthogonal matrix V' in the reduction
B = U * S * V'.
LDVT
LDVT is INTEGER
The leading dimension of the array VT.
WORK
WORK is COMPLEX*16 array, dimension (2*N)
RESID
RESID 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 zchkbb (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, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldab, * )
AB, integer LDAB, double precision, dimension( * ) BD, double precision, dimension( * )
BE, complex*16, dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldp, * ) P,
integer LDP, complex*16, dimension( ldc, * ) C, integer LDC, complex*16, dimension( ldc, *
) CC, complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension( * )
RWORK, double precision, dimension( * ) RESULT, integer INFO)
ZCHKBB
Purpose:
ZCHKBB tests the reduction of a general complex rectangular band
matrix to real bidiagonal form.
ZGBBRD factors a general band matrix A as Q B P* , where * means
conjugate transpose, B is upper bidiagonal, and Q and P are unitary;
ZGBBRD 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, ZCHKBB does nothing. NSIZES must be at
least zero.
MVAL
MVAL is INTEGER array, dimension (NSIZES)
The values of the matrix row dimension M.
NVAL
NVAL is INTEGER array, dimension (NSIZES)
The values of the matrix column dimension N.
NWDTHS
NWDTHS is INTEGER
The number of bandwidths to use. If it is zero,
ZCHKBB does nothing. It must be at least zero.
KK
KK is INTEGER array, dimension (NWDTHS)
An array containing the bandwidths to be used for the band
matrices. The values must be at least zero.
NTYPES
NTYPES is INTEGER
The number of elements in DOTYPE. If it is zero, ZCHKBB
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. .
DOTYPE
DOTYPE 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.
NRHS
NRHS is INTEGER
The number of columns in the "right-hand side" matrix C.
If NRHS = 0, then the operations on the right-hand side will
not be tested. NRHS must be at least 0.
ISEED
ISEED 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 ZCHKBB to continue the same random number
sequence.
THRESH
THRESH 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.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IINFO not equal to 0.)
A
A is DOUBLE PRECISION array, dimension
(LDA, max(NN))
Used to hold the matrix A.
LDA
LDA is INTEGER
The leading dimension of A. It must be at least 1
and at least max( NN ).
AB
AB is DOUBLE PRECISION array, dimension (LDAB, max(NN))
Used to hold A in band storage format.
LDAB
LDAB is INTEGER
The leading dimension of AB. It must be at least 2 (not 1!)
and at least max( KK )+1.
BD
BD is DOUBLE PRECISION array, dimension (max(NN))
Used to hold the diagonal of the bidiagonal matrix computed
by ZGBBRD.
BE
BE is DOUBLE PRECISION array, dimension (max(NN))
Used to hold the off-diagonal of the bidiagonal matrix
computed by ZGBBRD.
Q
Q is COMPLEX*16 array, dimension (LDQ, max(NN))
Used to hold the unitary matrix Q computed by ZGBBRD.
LDQ
LDQ is INTEGER
The leading dimension of Q. It must be at least 1
and at least max( NN ).
P
P is COMPLEX*16 array, dimension (LDP, max(NN))
Used to hold the unitary matrix P computed by ZGBBRD.
LDP
LDP is INTEGER
The leading dimension of P. It must be at least 1
and at least max( NN ).
C
C is COMPLEX*16 array, dimension (LDC, max(NN))
Used to hold the matrix C updated by ZGBBRD.
LDC
LDC is INTEGER
The leading dimension of U. It must be at least 1
and at least max( NN ).
CC
CC is COMPLEX*16 array, dimension (LDC, max(NN))
Used to hold a copy of the matrix C.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The number of entries in WORK. This must be at least
max( LDA+1, max(NN)+1 )*max(NN).
RWORK
RWORK is DOUBLE PRECISION array, dimension (max(NN))
RESULT
RESULT 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.
INFO
INFO 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 (1-10) 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 zchkbd (integer NSIZES, integer, dimension( * ) MVAL, integer, dimension( * ) NVAL,
integer NTYPES, logical, dimension( * ) DOTYPE, integer NRHS, integer, dimension( 4 )
ISEED, double precision THRESH, complex*16, dimension( lda, * ) A, integer LDA, double
precision, dimension( * ) BD, double precision, dimension( * ) BE, double precision,
dimension( * ) S1, double precision, dimension( * ) S2, complex*16, dimension( ldx, * ) X,
integer LDX, complex*16, dimension( ldx, * ) Y, complex*16, dimension( ldx, * ) Z,
complex*16, dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldpt, * ) PT,
integer LDPT, complex*16, dimension( ldpt, * ) U, complex*16, dimension( ldpt, * ) VT,
complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RWORK,
integer NOUT, integer INFO)
ZCHKBD
Purpose:
ZCHKBD checks the singular value decomposition (SVD) routines.
ZGEBRD reduces a complex general m by n matrix A to real upper or
lower bidiagonal form 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.
ZUNGBR generates the orthogonal matrices Q and P' from ZGEBRD.
Note that Q and P are not necessarily square.
ZBDSQR 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, ZBDSQR has an option to apply the left orthogonal matrix
U to a matrix X, useful in least squares applications.
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 ZGEBRD and ZUNGBR
(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 ZBDSQR 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) 0 if the true singular values of B are within THRESH of
those in S1. 2*THRESH if they are not. (Tested using
DSVDCH)
(10) | S1 - S2 | / ( |S1| ulp ), where S2 is computed without
computing U and V.
Test ZBDSQR 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 )
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) ZGEBRD 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 5--8 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).
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NVAL
NVAL is INTEGER array, dimension (NM)
The values of the matrix column dimension N.
NTYPES
NTYPES is INTEGER
The number of elements in DOTYPE. If it is zero, ZCHKBD
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. .
DOTYPE
DOTYPE 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.
NRHS
NRHS is INTEGER
The number of columns in the "right-hand side" matrices X, Y,
and Z, used in testing ZBDSQR. If NRHS = 0, then the
operations on the right-hand side will not be tested.
NRHS must be at least 0.
ISEED
ISEED 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 ZCHKBD to continue the same random
number sequence.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0. 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.
A
A is COMPLEX*16 array, dimension (LDA,NMAX)
where NMAX is the maximum value of N in NVAL.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,MMAX),
where MMAX is the maximum value of M in MVAL.
BD
BD is DOUBLE PRECISION array, dimension
(max(min(MVAL(j),NVAL(j))))
BE
BE is DOUBLE PRECISION array, dimension
(max(min(MVAL(j),NVAL(j))))
S1
S1 is DOUBLE PRECISION array, dimension
(max(min(MVAL(j),NVAL(j))))
S2
S2 is DOUBLE PRECISION array, dimension
(max(min(MVAL(j),NVAL(j))))
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
LDX
LDX is INTEGER
The leading dimension of the arrays X, Y, and Z.
LDX >= max(1,MMAX).
Y
Y is COMPLEX*16 array, dimension (LDX,NRHS)
Z
Z is COMPLEX*16 array, dimension (LDX,NRHS)
Q
Q is COMPLEX*16 array, dimension (LDQ,MMAX)
LDQ
LDQ is INTEGER
The leading dimension of the array Q. LDQ >= max(1,MMAX).
PT
PT is COMPLEX*16 array, dimension (LDPT,NMAX)
LDPT
LDPT is INTEGER
The leading dimension of the arrays PT, U, and V.
LDPT >= max(1, max(min(MVAL(j),NVAL(j)))).
U
U is COMPLEX*16 array, dimension
(LDPT,max(min(MVAL(j),NVAL(j))))
VT
VT is COMPLEX*16 array, dimension
(LDPT,max(min(MVAL(j),NVAL(j))))
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK 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))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(5*max(min(M,N)))
NOUT
NOUT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IINFO not equal to 0.)
INFO
INFO 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: LDP < 1 or LDP < MNMAX.
-27: LWORK too small.
If ZLATMR, CLATMS, ZGEBRD, ZUNGBR, or ZBDSQR,
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 (1-10) 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 zchkbk (integer NIN, integer NOUT)
ZCHKBK
Purpose:
ZCHKBK tests ZGEBAK, a routine for backward transformation of
the computed right or left eigenvectors if the orginal matrix
was preprocessed by balance subroutine ZGEBAL.
Parameters:
NIN
NIN is INTEGER
The logical unit number for input. NIN > 0.
NOUT
NOUT 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 zchkbl (integer NIN, integer NOUT)
ZCHKBL
Purpose:
ZCHKBL tests ZGEBAL, a routine for balancing a general complex
matrix and isolating some of its eigenvalues.
Parameters:
NIN
NIN is INTEGER
The logical unit number for input. NIN > 0.
NOUT
NOUT 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 zchkec (double precision THRESH, logical TSTERR, integer NIN, integer NOUT)
ZCHKEC
Purpose:
ZCHKEC tests eigen- condition estimation routines
ZTRSYL, CTREXC, CTRSNA, CTRSEN
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, ZTRSNA and CTRSEN 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.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NIN
NIN is INTEGER
The logical unit number for input.
NOUT
NOUT is INTEGER
The logical unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
September 2012
program zchkee ()
ZCHKEE
Purpose:
ZCHKEE tests the COMPLEX*16 LAPACK subroutines for the matrix
eigenvalue problem. The test paths in this version are
NEP (Nonsymmetric Eigenvalue Problem):
Test ZGEHRD, ZUNGHR, ZHSEQR, ZTREVC, ZHSEIN, and ZUNMHR
SEP (Hermitian Eigenvalue Problem):
Test ZHETRD, ZUNGTR, ZSTEQR, ZSTERF, ZSTEIN, ZSTEDC,
and drivers ZHEEV(X), ZHBEV(X), ZHPEV(X),
ZHEEVD, ZHBEVD, ZHPEVD
SVD (Singular Value Decomposition):
Test ZGEBRD, ZUNGBR, and ZBDSQR
and the drivers ZGESVD, ZGESDD
ZEV (Nonsymmetric Eigenvalue/eigenvector Driver):
Test ZGEEV
ZES (Nonsymmetric Schur form Driver):
Test ZGEES
ZVX (Nonsymmetric Eigenvalue/eigenvector Expert Driver):
Test ZGEEVX
ZSX (Nonsymmetric Schur form Expert Driver):
Test ZGEESX
ZGG (Generalized Nonsymmetric Eigenvalue Problem):
Test ZGGHD3, ZGGBAL, ZGGBAK, ZHGEQZ, and ZTGEVC
ZGS (Generalized Nonsymmetric Schur form Driver):
Test ZGGES
ZGV (Generalized Nonsymmetric Eigenvalue/eigenvector Driver):
Test ZGGEV
ZGX (Generalized Nonsymmetric Schur form Expert Driver):
Test ZGGESX
ZXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver):
Test ZGGEVX
ZSG (Hermitian Generalized Eigenvalue Problem):
Test ZHEGST, ZHEGV, ZHEGVD, ZHEGVX, ZHPGST, ZHPGV, ZHPGVD,
ZHPGVX, ZHBGST, ZHBGV, ZHBGVD, and ZHBGVX
ZHB (Hermitian Band Eigenvalue Problem):
Test ZHBTRD
ZBB (Band Singular Value Decomposition):
Test ZGBBRD
ZEC (Eigencondition estimation):
Test ZTRSYL, ZTREXC, ZTRSNA, and ZTRSEN
ZBL (Balancing a general matrix)
Test ZGEBAL
ZBK (Back transformation on a balanced matrix)
Test ZGEBAK
ZGL (Balancing a matrix pair)
Test ZGGBAL
ZGK (Back transformation on a matrix pair)
Test ZGGBAK
GLM (Generalized Linear Regression Model):
Tests ZGGGLM
GQR (Generalized QR and RQ factorizations):
Tests ZGGQRF and ZGGRQF
GSV (Generalized Singular Value Decomposition):
Tests ZGGSVD, ZGGSVP, ZTGSJA, ZLAGS2, ZLAPLL, and ZLAPMT
CSD (CS decomposition):
Tests ZUNCSD
LSE (Constrained Linear Least Squares):
Tests ZGGLSE
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
3-character path names in columns 1-3. 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
ZHS or NEP 21 ZCHKHS
ZST or SEP 21 ZCHKST (routines)
18 ZDRVST (drivers)
ZBD or SVD 16 ZCHKBD (routines)
5 ZDRVBD (drivers)
ZEV 21 ZDRVEV
ZES 21 ZDRVES
ZVX 21 ZDRVVX
ZSX 21 ZDRVSX
ZGG 26 ZCHKGG (routines)
ZGS 26 ZDRGES
ZGX 5 ZDRGSX
ZGV 26 ZDRGEV
ZXV 2 ZDRGVX
ZSG 21 ZDRVSG
ZHB 15 ZCHKHB
ZBB 15 ZCHKBB
ZEC - ZCHKEC
ZBL - ZCHKBL
ZBK - ZCHKBK
ZGL - ZCHKGL
ZGK - ZCHKGK
GLM 8 ZCKGLM
GQR 8 ZCKGQR
GSV 8 ZCKGSV
CSD 3 ZCKCSD
LSE 8 ZCKLSE
-----------------------------------------------------------------------
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 15-EOF: The remaining lines occur in sets of 1 or 2 and allow
the user to specify the matrix types. Each line contains
a 3-character path name in columns 1-3, and the number
of matrix types must be the first nonblank item in columns
4-80. 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 3-character path names are 'NEP' or 'ZHS' for the
nonsymmetric eigenvalue routines.
-----------------------------------------------------------------------
SEP or ZSG 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 13-EOF: Lines specifying matrix types, as for NEP.
The valid 3-character path names are 'SEP' or 'ZST' for the
Hermitian eigenvalue routines and driver routines, and
'ZSG' for the routines for the Hermitian 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 15-EOF: Lines specifying matrix types, as for NEP.
The 3-character path names are 'SVD' or 'ZBD' for both the
SVD routines and the SVD driver routines.
-----------------------------------------------------------------------
ZEV and ZES data files:
line 1: 'ZEV' or 'ZES' 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: 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.
lines 8 and following: Lines specifying matrix types, as for NEP.
The 3-character path name is 'ZEV' to test CGEEV, or
'ZES' to test CGEES.
-----------------------------------------------------------------------
The ZVX data has two parts. The first part is identical to ZEV,
and the second part consists of test matrices with precomputed
solutions.
line 1: 'ZVX' in columns 1-3.
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: NEWSD, INTEGER
If line 6 was 2:
line 7: INTEGER array, dimension (4)
lines 8 and following: The first line contains 'ZVX' in columns 1-3
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+N+N**2 lines, where N is
its dimension. The first line contains the dimension N and
ISRT (two integers). ISRT indicates whether the last N lines
are sorted by increasing real part of the eigenvalue
(ISRT=0) or by increasing imaginary part (ISRT=1). The next
N**2 lines contain the matrix rowwise, one entry 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 eigenvalues, the imaginary part of the eigenvalue, the
reciprocal condition number of the eigenvalues, and the
reciprocal condition number of the vector 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 ZSX data is like ZVX. The first part is identical to ZEV, and the
second part consists of test matrices with precomputed solutions.
line 1: 'ZSX' in columns 1-3.
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: NEWSD, INTEGER
If line 6 was 2:
line 7: INTEGER array, dimension (4)
lines 8 and following: The first line contains 'ZSX' in columns 1-3
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**2 lines, where N is
its dimension. The first line contains the dimension N, the
dimension M of an invariant subspace, and ISRT. 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 (if ISRT=0) or
by increasing imaginary part (if ISRT=1)). The next N**2
lines contain the matrix rowwise. 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 in
indicated by a line containing N=0, M=0, and ISRT = 0. Even
if no data is to be tested, there must be at least one line
containing N=0, M=0 and ISRT=0.
-----------------------------------------------------------------------
ZGG 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, NBCOL, 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 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 17-EOF: Lines specifying matrix types, as for NEP.
The 3-character path name is 'ZGG' for the generalized
eigenvalue problem routines and driver routines.
-----------------------------------------------------------------------
ZGS and ZGV input files:
line 1: 'ZGS' or 'ZGV' 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 7-EOF: Lines specifying matrix types, as for NEP.
The 3-character path name is 'ZGS' for the generalized
eigenvalue problem routines and driver routines.
-----------------------------------------------------------------------
ZGX input file:
line 1: 'ZGX' 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 7-EOF: Precomputed examples are tested.
remaining lines : Each example is stored on 3+2*N*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*N
lines contain the matrix A, one element per line. The next N*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.
-----------------------------------------------------------------------
ZXV input files:
line 1: 'ZXV' 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 7-EOF: Precomputed examples are tested.
remaining lines : Each example is stored on 3+2*N*N lines, where N is
its dimension. The first line contains the dimension (a
single integer). The next N*N lines contain the matrix A, one
element per line. The next N*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.
-----------------------------------------------------------------------
ZHB 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 8-EOF: Lines specifying matrix types, as for NEP.
The 3-character path name is 'ZHB'.
-----------------------------------------------------------------------
ZBB 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 10-EOF: Lines specifying matrix types, as for SVD.
The 3-character path name is 'ZBB'.
-----------------------------------------------------------------------
ZEC 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 3-EOF:
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.
-----------------------------------------------------------------------
ZBL and ZBK input files:
line 1: 'ZBL' in columns 1-3 to test CGEBAL, or 'ZBK' in
columns 1-3 to test CGEBAK.
The remaining lines consist of specially constructed test cases.
-----------------------------------------------------------------------
ZGL and ZGK input files:
line 1: 'ZGL' in columns 1-3 to test ZGGBAL, or 'ZGK' in
columns 1-3 to test ZGGBAK.
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 9-EOF: Lines specifying matrix types, as for NEP.
The 3-character 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 9-EOF: Lines specifying matrix types, as for NEP.
The 3-character 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 9-EOF: Lines specifying matrix types, as for NEP.
The 3-character 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 top-left block).
line 5: NVAL, INTEGER array, dimension(NM)
Values of N (column dimension of top-left 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 9-EOF: Lines specifying matrix types, as for NEP.
The 3-character 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 9-EOF: Lines specifying matrix types, as for NEP.
The 3-character 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+20) 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 N-by-N matrices for ZGG.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zchkgg (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, logical
TSTDIF, double precision THRSHN, integer NOUNIT, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( lda, * ) B, complex*16, dimension( lda, * ) H,
complex*16, dimension( lda, * ) T, complex*16, dimension( lda, * ) S1, complex*16,
dimension( lda, * ) S2, complex*16, dimension( lda, * ) P1, complex*16, dimension( lda, *
) P2, complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension( ldu, * ) V,
complex*16, dimension( ldu, * ) Q, complex*16, dimension( ldu, * ) Z, complex*16,
dimension( * ) ALPHA1, complex*16, dimension( * ) BETA1, complex*16, dimension( * )
ALPHA3, complex*16, dimension( * ) BETA3, complex*16, dimension( ldu, * ) EVECTL,
complex*16, dimension( ldu, * ) EVECTR, complex*16, dimension( * ) WORK, integer LWORK,
double precision, dimension( * ) RWORK, logical, dimension( * ) LLWORK, double precision,
dimension( 15 ) RESULT, integer INFO)
ZCHKGG
Purpose:
ZCHKGG checks the nonsymmetric generalized eigenvalue problem
routines.
H H H
ZGGHRD factors A and B as U H V and U T V , where means conjugate
transpose, H is hessenberg, T is triangular and U and V are unitary.
H H
ZHGEQZ factors H and T as Q S Z and Q P Z , where P and S are upper
triangular and Q and Z are unitary. 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
ZTGEVC 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 ZCHKGG 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. The first twelve "test ratios" should be
small -- O(1). They will be compared with the threshold THRESH:
H
(1) | A - U H V | / ( |A| n ulp )
H
(2) | B - U T V | / ( |B| n ulp )
H
(3) | I - UU | / ( n ulp )
H
(4) | I - VV | / ( n ulp )
H
(5) | H - Q S Z | / ( |H| n ulp )
H
(6) | T - Q P Z | / ( |T| n ulp )
H
(7) | I - QQ | / ( n ulp )
H
(8) | I - ZZ | / ( n ulp )
(9) max over all left eigenvalue/-vector pairs (beta/alpha,l) of
H
| (beta A - alpha B) l | / ( ulp max( |beta A|, |alpha B| ) )
(10) max over all left eigenvalue/-vector pairs (beta/alpha,l') of
H
| (beta H - alpha T) l' | / ( ulp max( |beta H|, |alpha T| ) )
where the eigenvectors l' are the result of passing Q to
DTGEVC and back transforming (JOB='B').
(11) max over all right eigenvalue/-vector pairs (beta/alpha,r) of
| (beta A - alpha B) r | / ( ulp max( |beta A|, |alpha B| ) )
(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 (JOB='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=(N-1)/2
(7) ( D, I ) where D is P*D1, P is a random unitary diagonal
matrix (i.e., with random magnitude 1 entries
on the diagonal), and D1=diag( 0, 1,..., N-1 )
(i.e., a diagonal matrix with D1(1,1)=0,
D1(2,2)=1, ..., D1(N,N)=N-1.)
(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=P*diag( 0, 0, 1, ..., N-3, 0 ) and
D2=Q*diag( 0, N-3, N-4,..., 1, 0, 0 ), and
P and Q are random unitary diagonal matrices.
t t
(16) U ( J , J ) V where U and V are random unitary 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) =
P*( 0, 0, 1, ..., N-3, 0 ) and diag(T2) =
Q*( 0, N-3, N-4,..., 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, 1-d, ..., 1-(N-5)*d=s, 0 )
diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 )
N-5
(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(N-4), 0 )
diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )
where r1,..., r(N-4) are random.
(22) U ( big*T1, small*T2 ) V diag(T1) = P*( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(23) U ( small*T1, big*T2 ) V diag(T1) = P*( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(24) U ( small*T1, small*T2 ) V diag(T1) = P*( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(25) U ( big*T1, big*T2 ) V diag(T1) = P*( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(26) U ( T1, T2 ) V where T1 and T2 are random upper-triangular
matrices.
Parameters:
NSIZES
NSIZES is INTEGER
The number of sizes of matrices to use. If it is zero,
ZCHKGG does nothing. It must be at least zero.
NN
NN 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.
NTYPES
NTYPES is INTEGER
The number of elements in DOTYPE. If it is zero, ZCHKGG
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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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 ZCHKGG to continue the same random number
sequence.
THRESH
THRESH 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.
TSTDIF
TSTDIF is LOGICAL
Specifies whether test ratios 13-15 will be computed and
compared with THRESH.
= .FALSE.: Only test ratios 1-12 will be computed and tested.
Ratios 13-15 will be set to zero.
= .TRUE.: All the test ratios 1-15 will be computed and
tested.
THRSHN
THRSHN 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 5--10.)
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IINFO not equal to 0.)
A
A is COMPLEX*16 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.
LDA
LDA 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 ).
B
B is COMPLEX*16 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.
H
H is COMPLEX*16 array, dimension (LDA, max(NN))
The upper Hessenberg matrix computed from A by ZGGHRD.
T
T is COMPLEX*16 array, dimension (LDA, max(NN))
The upper triangular matrix computed from B by ZGGHRD.
S1
S1 is COMPLEX*16 array, dimension (LDA, max(NN))
The Schur (upper triangular) matrix computed from H by ZHGEQZ
when Q and Z are also computed.
S2
S2 is COMPLEX*16 array, dimension (LDA, max(NN))
The Schur (upper triangular) matrix computed from H by ZHGEQZ
when Q and Z are not computed.
P1
P1 is COMPLEX*16 array, dimension (LDA, max(NN))
The upper triangular matrix computed from T by ZHGEQZ
when Q and Z are also computed.
P2
P2 is COMPLEX*16 array, dimension (LDA, max(NN))
The upper triangular matrix computed from T by ZHGEQZ
when Q and Z are not computed.
U
U is COMPLEX*16 array, dimension (LDU, max(NN))
The (left) unitary matrix computed by ZGGHRD.
LDU
LDU is INTEGER
The leading dimension of U, V, Q, Z, EVECTL, and EVEZTR. It
must be at least 1 and at least max( NN ).
V
V is COMPLEX*16 array, dimension (LDU, max(NN))
The (right) unitary matrix computed by ZGGHRD.
Q
Q is COMPLEX*16 array, dimension (LDU, max(NN))
The (left) unitary matrix computed by ZHGEQZ.
Z
Z is COMPLEX*16 array, dimension (LDU, max(NN))
The (left) unitary matrix computed by ZHGEQZ.
ALPHA1
ALPHA1 is COMPLEX*16 array, dimension (max(NN))
BETA1
BETA1 is COMPLEX*16 array, dimension (max(NN))
The generalized eigenvalues of (A,B) computed by ZHGEQZ
when Q, Z, and the full Schur matrices are computed.
ALPHA3
ALPHA3 is COMPLEX*16 array, dimension (max(NN))
BETA3
BETA3 is COMPLEX*16 array, dimension (max(NN))
The generalized eigenvalues of (A,B) computed by ZHGEQZ
when neither Q, Z, nor the Schur matrices are computed.
EVECTL
EVECTL is COMPLEX*16 array, dimension (LDU, max(NN))
The (lower triangular) left eigenvector matrix for the
matrices in S1 and P1.
EVECTR
EVECTR is COMPLEX*16 array, dimension (LDU, max(NN))
The (upper triangular) right eigenvector matrix for the
matrices in S1 and P1.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The number of entries in WORK. This must be at least
max( 4*N, 2 * N**2, 1 ), for all N=NN(j).
RWORK
RWORK is DOUBLE PRECISION array, dimension (2*max(NN))
LLWORK
LLWORK is LOGICAL array, dimension (max(NN))
RESULT
RESULT 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.
INFO
INFO is INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th 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:
November 2011
subroutine zchkgk (integer NIN, integer NOUT)
ZCHKGK
Purpose:
ZCHKGK tests ZGGBAK, a routine for backward balancing of
a matrix pair (A, B).
Parameters:
NIN
NIN is INTEGER
The logical unit number for input. NIN > 0.
NOUT
NOUT 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 zchkgl (integer NIN, integer NOUT)
ZCHKGL
Purpose:
ZCHKGL tests ZGGBAL, a routine for balancing a matrix pair (A, B).
Parameters:
NIN
NIN is INTEGER
The logical unit number for input. NIN > 0.
NOUT
NOUT 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 zchkhb (integer NSIZES, integer, dimension( * ) NN, integer NWDTHS, integer,
dimension( * ) KK, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 )
ISEED, double precision THRESH, integer NOUNIT, complex*16, dimension( lda, * ) A, integer
LDA, double precision, dimension( * ) SD, double precision, dimension( * ) SE, complex*16,
dimension( ldu, * ) U, integer LDU, complex*16, dimension( * ) WORK, integer LWORK, double
precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT, integer INFO)
ZCHKHB
Purpose:
ZCHKHB tests the reduction of a Hermitian band matrix to tridiagonal
from, used with the Hermitian eigenvalue problem.
ZHBTRD factors a Hermitian band matrix A as U S U* , where * means
conjugate transpose, S is symmetric tridiagonal, and U is unitary.
ZHBTRD can use either just the lower or just the upper triangle
of A; ZCHKHB checks both cases.
When ZCHKHB 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 hermitian banded reduction routine. For each
matrix, a number of tests will be performed:
(1) | A - V S V* | / ( |A| n ulp ) computed by ZHBTRD with
UPLO='U'
(2) | I - UU* | / ( n ulp )
(3) | A - V S V* | / ( |A| n ulp ) computed by ZHBTRD 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 unitary 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 unitary 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 unitary 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) Hermitian 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,
ZCHKHB does nothing. It must be at least zero.
NN
NN 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.
NWDTHS
NWDTHS is INTEGER
The number of bandwidths to use. If it is zero,
ZCHKHB does nothing. It must be at least zero.
KK
KK is INTEGER array, dimension (NWDTHS)
An array containing the bandwidths to be used for the band
matrices. The values must be at least zero.
NTYPES
NTYPES is INTEGER
The number of elements in DOTYPE. If it is zero, ZCHKHB
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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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 ZCHKHB to continue the same random number
sequence.
THRESH
THRESH 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.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IINFO not equal to 0.)
A
A is COMPLEX*16 array, dimension
(LDA, max(NN))
Used to hold the matrix whose eigenvalues are to be
computed.
LDA
LDA is INTEGER
The leading dimension of A. It must be at least 2 (not 1!)
and at least max( KK )+1.
SD
SD is DOUBLE PRECISION array, dimension (max(NN))
Used to hold the diagonal of the tridiagonal matrix computed
by ZHBTRD.
SE
SE is DOUBLE PRECISION array, dimension (max(NN))
Used to hold the off-diagonal of the tridiagonal matrix
computed by ZHBTRD.
U
U is COMPLEX*16 array, dimension (LDU, max(NN))
Used to hold the unitary matrix computed by ZHBTRD.
LDU
LDU is INTEGER
The leading dimension of U. It must be at least 1
and at least max( NN ).
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The number of entries in WORK. This must be at least
max( LDA+1, max(NN)+1 )*max(NN).
RWORK
RWORK is DOUBLE PRECISION array
RESULT
RESULT 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.
INFO
INFO 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 (1-10) 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 zchkhs (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) H,
complex*16, dimension( lda, * ) T1, complex*16, dimension( lda, * ) T2, complex*16,
dimension( ldu, * ) U, integer LDU, complex*16, dimension( ldu, * ) Z, complex*16,
dimension( ldu, * ) UZ, complex*16, dimension( * ) W1, complex*16, dimension( * ) W3,
complex*16, dimension( ldu, * ) EVECTL, complex*16, dimension( ldu, * ) EVECTR,
complex*16, dimension( ldu, * ) EVECTY, complex*16, dimension( ldu, * ) EVECTX,
complex*16, dimension( ldu, * ) UU, complex*16, dimension( * ) TAU, complex*16, dimension(
* ) WORK, integer NWORK, double precision, dimension( * ) RWORK, integer, dimension( * )
IWORK, logical, dimension( * ) SELECT, double precision, dimension( 14 ) RESULT, integer
INFO)
ZCHKHS
Purpose:
ZCHKHS checks the nonsymmetric eigenvalue problem routines.
ZGEHRD factors A as U H U' , where ' means conjugate
transpose, H is hessenberg, and U is unitary.
ZUNGHR generates the unitary matrix U.
ZUNMHR multiplies a matrix by the unitary matrix U.
ZHSEQR factors H as Z T Z' , where Z is unitary and T
is upper triangular. It also computes the eigenvalues,
w(1), ..., w(n); we define a diagonal matrix W whose
(diagonal) entries are the eigenvalues.
ZTREVC computes the left eigenvector matrix L and the
right eigenvector matrix R for the matrix T. The
columns of L are the complex conjugates of the left
eigenvectors of T. The columns of R are the right
eigenvectors of T. L is lower triangular, and R is
upper triangular.
ZHSEIN computes the left eigenvector matrix Y and the
right eigenvector matrix X for the matrix H. The
columns of Y are the complex conjugates of the left
eigenvectors of H. The columns of X are the right
eigenvectors of H. Y is lower triangular, and X is
upper triangular.
When ZCHKHS 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**H | / ( |A| n ulp )
(2) | I - UU**H | / ( n ulp )
(3) | H - Z T Z**H | / ( |H| n ulp )
(4) | I - ZZ**H | / ( n ulp )
(5) | A - UZ H (UZ)**H | / ( |A| n ulp )
(6) | I - UZ (UZ)**H | / ( 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 complex angles.
(ULP = (first number larger than 1) - 1 )
(5) A diagonal matrix with geometrically spaced entries
1, ..., ULP and random complex angles.
(6) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
and random complex angles.
(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 unitary and
T has evenly spaced entries 1, ..., ULP with random complex
angles on the diagonal and random O(1) entries in the upper
triangle.
(10) A matrix of the form U' T U, where U is unitary and
T has geometrically spaced entries 1, ..., ULP with random
complex angles on the diagonal and random O(1) entries in
the upper triangle.
(11) A matrix of the form U' T U, where U is unitary and
T has "clustered" entries 1, ULP,..., ULP with random
complex angles on the diagonal and random O(1) entries in
the upper triangle.
(12) A matrix of the form U' T U, where U is unitary and
T has complex eigenvalues randomly chosen from
ULP < |z| < 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 complex angles 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 complex angles 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 complex angles 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 complex eigenvalues randomly chosen
from ULP < |z| < 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 |z| < 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,
ZCHKHS 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, ZCHKHS
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 ZCHKHS 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 - COMPLEX*16 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 - COMPLEX*16 array, dimension (LDA,max(NN))
The upper hessenberg matrix computed by ZGEHRD. On exit,
H contains the Hessenberg form of the matrix in A.
Modified.
T1 - COMPLEX*16 array, dimension (LDA,max(NN))
The Schur (="quasi-triangular") matrix computed by ZHSEQR
if Z is computed. On exit, T1 contains the Schur form of
the matrix in A.
Modified.
T2 - COMPLEX*16 array, dimension (LDA,max(NN))
The Schur matrix computed by ZHSEQR 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 - COMPLEX*16 array, dimension (LDU,max(NN))
The unitary matrix computed by ZGEHRD.
Modified.
Z - COMPLEX*16 array, dimension (LDU,max(NN))
The unitary matrix computed by ZHSEQR.
Modified.
UZ - COMPLEX*16 array, dimension (LDU,max(NN))
The product of U times Z.
Modified.
W1 - COMPLEX*16 array, dimension (max(NN))
The eigenvalues of A, as computed by a full Schur
decomposition H = Z T Z'. On exit, W1 contains the
eigenvalues of the matrix in A.
Modified.
W3 - COMPLEX*16 array, dimension (max(NN))
The eigenvalues of A, as computed by a partial Schur
decomposition (Z not computed, T only computed as much
as is necessary for determining eigenvalues). On exit,
W3 contains the eigenvalues of the matrix in A, possibly
perturbed by ZHSEIN.
Modified.
EVECTL - COMPLEX*16 array, dimension (LDU,max(NN))
The conjugate transpose of the (upper triangular) left
eigenvector matrix for the matrix in T1.
Modified.
EVEZTR - COMPLEX*16 array, dimension (LDU,max(NN))
The (upper triangular) right eigenvector matrix for the
matrix in T1.
Modified.
EVECTY - COMPLEX*16 array, dimension (LDU,max(NN))
The conjugate transpose of the left eigenvector matrix
for the matrix in H.
Modified.
EVECTX - COMPLEX*16 array, dimension (LDU,max(NN))
The right eigenvector matrix for the matrix in H.
Modified.
UU - COMPLEX*16 array, dimension (LDU,max(NN))
Details of the unitary matrix computed by ZGEHRD.
Modified.
TAU - COMPLEX*16 array, dimension (max(NN))
Further details of the unitary matrix computed by ZGEHRD.
Modified.
WORK - COMPLEX*16 array, dimension (NWORK)
Workspace.
Modified.
NWORK - INTEGER
The number of entries in WORK. NWORK >= 4*NN(j)*NN(j) + 2.
RWORK - DOUBLE PRECISION array, dimension (max(NN))
Workspace. Could be equivalenced to IWORK, but not SELECT.
Modified.
IWORK - INTEGER array, dimension (max(NN))
Workspace.
Modified.
SELECT - LOGICAL array, dimension (max(NN))
Workspace. Could be equivalenced to IWORK, but not RWORK.
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.
-26: NWORK too small.
If ZLATMR, CLATMS, or CLATME returns an error code, the
absolute value of it is returned.
If 1, then ZHSEQR 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 (1-10) 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 2011
subroutine zchkst (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, 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, complex*16, dimension(
ldu, * ) U, integer LDU, complex*16, dimension( ldu, * ) V, complex*16, dimension( * ) VP,
complex*16, dimension( * ) TAU, complex*16, dimension( ldu, * ) Z, complex*16, dimension(
* ) WORK, integer LWORK, double precision, dimension( * ) RWORK, integer LRWORK, integer,
dimension( * ) IWORK, integer LIWORK, double precision, dimension( * ) RESULT, integer
INFO)
ZCHKST
Purpose:
ZCHKST checks the Hermitian eigenvalue problem routines.
ZHETRD factors A as U S U* , where * means conjugate transpose,
S is real symmetric tridiagonal, and U is unitary.
ZHETRD can use either just the lower or just the upper triangle
of A; ZCHKST checks both cases.
U is represented as a product of Householder
transformations, whose vectors are stored in the first
n-1 columns of V, and whose scale factors are in TAU.
ZHPTRD does the same as ZHETRD, except that A and V are stored
in "packed" format.
ZUNGTR constructs the matrix U from the contents of V and TAU.
ZUPGTR constructs the matrix U from the contents of VP and TAU.
ZSTEQR factors S as Z D1 Z* , where Z is the unitary
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.
ZPTEQR factors S as Z4 D4 Z4* , for a
Hermitian 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.
ZSTEIN computes Y, the eigenvectors of S, given the
eigenvalues.
ZSTEDC factors S as Z D1 Z* , where Z is the unitary
matrix of eigenvectors and D1 is a diagonal matrix with
the eigenvalues on the diagonal ('I' option). It may also
update an input unitary matrix, usually the output
from ZHETRD/ZUNGTR or ZHPTRD/ZUPGTR ('V' option). It may
also just compute eigenvalues ('N' option).
ZSTEMR factors S as Z D1 Z* , where Z is the unitary
matrix of eigenvectors and D1 is a diagonal matrix with
the eigenvalues on the diagonal ('I' option). ZSTEMR
uses the Relatively Robust Representation whenever possible.
When ZCHKST 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 Hermitian eigenroutines. For each matrix, a number
of tests will be performed:
(1) | A - V S V* | / ( |A| n ulp ) ZHETRD( UPLO='U', ... )
(2) | I - UV* | / ( n ulp ) ZUNGTR( UPLO='U', ... )
(3) | A - V S V* | / ( |A| n ulp ) ZHETRD( UPLO='L', ... )
(4) | I - UV* | / ( n ulp ) ZUNGTR( UPLO='L', ... )
(5-8) Same as 1-4, but for ZHPTRD and ZUPGTR.
(9) | S - Z D Z* | / ( |S| n ulp ) ZSTEQR('V',...)
(10) | I - ZZ* | / ( n ulp ) ZSTEQR('V',...)
(11) | D1 - D2 | / ( |D1| ulp ) ZSTEQR('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 ) ZPTEQR('V',...)
(15) | I - Z4 Z4* | / ( n ulp ) ZPTEQR('V',...)
(16) | D4 - D5 | / ( 100 |D4| ulp ) ZPTEQR('N',...)
When S is also diagonally dominant by the factor gamma < 1,
(17) max | D4(i) - WR(i) | / ( |D4(i)| omega ) ,
i
omega = 2 (2n-1) 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, ZSTEIN
(21) | I - Y Y* | / ( n ulp ) DSTEBZ, ZSTEIN
(22) | S - Z D Z* | / ( |S| n ulp ) ZSTEDC('I')
(23) | I - ZZ* | / ( n ulp ) ZSTEDC('I')
(24) | S - Z D Z* | / ( |S| n ulp ) ZSTEDC('V')
(25) | I - ZZ* | / ( n ulp ) ZSTEDC('V')
(26) | D1 - D2 | / ( |D1| ulp ) ZSTEDC('V') and
ZSTEDC('N')
Test 27 is disabled at the moment because ZSTEMR does not
guarantee high relatvie accuracy.
(27) max | D6(i) - WR(i) | / ( |D6(i)| omega ) ,
i
omega = 2 (2n-1) ULP (1 + 8 gamma**2) / (1 - gamma)**4
ZSTEMR('V', 'A')
(28) max | D6(i) - WR(i) | / ( |D6(i)| omega ) ,
i
omega = 2 (2n-1) ULP (1 + 8 gamma**2) / (1 - gamma)**4
ZSTEMR('V', 'I')
Tests 29 through 34 are disable at present because ZSTEMR
does not handle partial specturm requests.
(29) | S - Z D Z* | / ( |S| n ulp ) ZSTEMR('V', 'I')
(30) | I - ZZ* | / ( n ulp ) ZSTEMR('V', 'I')
(31) ( max { min | WA2(i)-WA3(j) | } +
i j
max { min | WA3(i)-WA2(j) | } ) / ( |D3| ulp )
i j
ZSTEMR('N', 'I') vs. CSTEMR('V', 'I')
(32) | S - Z D Z* | / ( |S| n ulp ) ZSTEMR('V', 'V')
(33) | I - ZZ* | / ( n ulp ) ZSTEMR('V', 'V')
(34) ( max { min | WA2(i)-WA3(j) | } +
i j
max { min | WA3(i)-WA2(j) | } ) / ( |D3| ulp )
i j
ZSTEMR('N', 'V') vs. CSTEMR('V', 'V')
(35) | S - Z D Z* | / ( |S| n ulp ) ZSTEMR('V', 'A')
(36) | I - ZZ* | / ( n ulp ) ZSTEMR('V', 'A')
(37) ( max { min | WA2(i)-WA3(j) | } +
i j
max { min | WA3(i)-WA2(j) | } ) / ( |D3| ulp )
i j
ZSTEMR('N', 'A') vs. CSTEMR('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 unitary 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 unitary 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 unitary 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) Hermitian 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,
ZCHKST does nothing. It must be at least zero.
NN
NN 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.
NTYPES
NTYPES is INTEGER
The number of elements in DOTYPE. If it is zero, ZCHKST
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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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 ZCHKST to continue the same random number
sequence.
THRESH
THRESH 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.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IINFO not equal to 0.)
A
A is COMPLEX*16 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.
LDA
LDA is INTEGER
The leading dimension of A. It must be at
least 1 and at least max( NN ).
AP
AP is COMPLEX*16 array of
dimension( max(NN)*max(NN+1)/2 )
The matrix A stored in packed format.
SD
SD is DOUBLE PRECISION array of
dimension( max(NN) )
The diagonal of the tridiagonal matrix computed by ZHETRD.
On exit, SD and SE contain the tridiagonal form of the
matrix in A.
SE
SE is DOUBLE PRECISION array of
dimension( max(NN) )
The off-diagonal of the tridiagonal matrix computed by
ZHETRD. On exit, SD and SE contain the tridiagonal form of
the matrix in A.
D1
D1 is DOUBLE PRECISION array of
dimension( max(NN) )
The eigenvalues of A, as computed by ZSTEQR simlutaneously
with Z. On exit, the eigenvalues in D1 correspond with the
matrix in A.
D2
D2 is DOUBLE PRECISION array of
dimension( max(NN) )
The eigenvalues of A, as computed by ZSTEQR if Z is not
computed. On exit, the eigenvalues in D2 correspond with
the matrix in A.
D3
D3 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.
D4
D4 is DOUBLE PRECISION array of
dimension( max(NN) )
The eigenvalues of A, as computed by ZPTEQR(V).
ZPTEQR factors S as Z4 D4 Z4*
On exit, the eigenvalues in D4 correspond with the matrix in A.
D5
D5 is DOUBLE PRECISION array of
dimension( max(NN) )
The eigenvalues of A, as computed by ZPTEQR(N)
when Z is not computed. On exit, the
eigenvalues in D4 correspond with the matrix in A.
WA1
WA1 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.
WA2
WA2 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
IL-th through IU-th eigenvalues.
WA3
WA3 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 IL-th and IU-th
eigenvalues and ask for all eigenvalues in this range.
WR
WR is DOUBLE PRECISION array of
dimension( max(NN) )
All eigenvalues of A, computed to high
absolute accuracy, with different options.
as computed by DSTEBZ.
U
U is COMPLEX*16 array of
dimension( LDU, max(NN) ).
The unitary matrix computed by ZHETRD + ZUNGTR.
LDU
LDU is INTEGER
The leading dimension of U, Z, and V. It must be at least 1
and at least max( NN ).
V
V is COMPLEX*16 array of
dimension( LDU, max(NN) ).
The Housholder vectors computed by ZHETRD 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 ZHETRD, 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 ZUNGTR, set those entries to
1 before using them, and then restore them later.)
VP
VP is COMPLEX*16 array of
dimension( max(NN)*max(NN+1)/2 )
The matrix V stored in packed format.
TAU
TAU is COMPLEX*16 array of
dimension( max(NN) )
The Householder factors computed by ZHETRD in reducing A
to tridiagonal form.
Z
Z is COMPLEX*16 array of
dimension( LDU, max(NN) ).
The unitary matrix of eigenvectors computed by ZSTEQR,
ZPTEQR, and ZSTEIN.
WORK
WORK is COMPLEX*16 array of
dimension( LWORK )
LWORK
LWORK 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.
IWORK
IWORK is INTEGER array,
Workspace.
LIWORK
LIWORK 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.
RWORK
RWORK is DOUBLE PRECISION array
LRWORK
LRWORK is INTEGER
The number of entries in LRWORK (dimension( ??? )
RESULT
RESULT 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.
INFO
INFO 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 ZLATMR, CLATMS, ZHETRD, ZUNGTR, ZSTEQR, DSTERF,
or ZUNMC2 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 (1-10) 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 zckcsd (integer NM, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL,
integer, dimension( * ) QVAL, integer NMATS, integer, dimension( 4 ) ISEED, double
precision THRESH, integer MMAX, complex*16, dimension( * ) X, complex*16, dimension( * )
XF, complex*16, dimension( * ) U1, complex*16, dimension( * ) U2, complex*16, dimension( *
) V1T, complex*16, dimension( * ) V2T, double precision, dimension( * ) THETA, integer,
dimension( * ) IWORK, complex*16, dimension( * ) WORK, double precision, dimension( * )
RWORK, integer NIN, integer NOUT, integer INFO)
ZCKCSD
Purpose:
ZCKCSD tests ZUNCSD:
the CSD for an M-by-M unitary matrix X partitioned as
[ X11 X12; X21 X22 ]. X11 is P-by-Q.
Parameters:
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
PVAL
PVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension P.
QVAL
QVAL is INTEGER array, dimension (NM)
The values of the matrix column dimension Q.
NMATS
NMATS 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.
ISEED
ISEED 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.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
MMAX
MMAX is INTEGER
The maximum value permitted for M, used in dimensioning the
work arrays.
X
X is COMPLEX*16 array, dimension (MMAX*MMAX)
XF
XF is COMPLEX*16 array, dimension (MMAX*MMAX)
U1
U1 is COMPLEX*16 array, dimension (MMAX*MMAX)
U2
U2 is COMPLEX*16 array, dimension (MMAX*MMAX)
V1T
V1T is COMPLEX*16 array, dimension (MMAX*MMAX)
V2T
V2T is COMPLEX*16 array, dimension (MMAX*MMAX)
THETA
THETA is DOUBLE PRECISION array, dimension (MMAX)
IWORK
IWORK is INTEGER array, dimension (MMAX)
WORK
WORK is COMPLEX*16 array
RWORK
RWORK is DOUBLE PRECISION array
NIN
NIN is INTEGER
The unit number for input.
NOUT
NOUT is INTEGER
The unit number for output.
INFO
INFO is INTEGER
= 0 : successful exit
> 0 : If ZLAROR 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 zckglm (integer NN, integer, dimension( * ) NVAL, integer, dimension( * ) MVAL,
integer, dimension( * ) PVAL, integer NMATS, integer, dimension( 4 ) ISEED, double
precision THRESH, integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * )
AF, complex*16, dimension( * ) B, complex*16, dimension( * ) BF, complex*16, dimension( *
) X, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN,
integer NOUT, integer INFO)
ZCKGLM
Purpose:
ZCKGLM tests ZGGGLM - 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.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix row dimension N.
MVAL
MVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension M.
PVAL
PVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension P.
NMATS
NMATS 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.
ISEED
ISEED 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.
THRESH
THRESH 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.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AF
AF is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NMAX)
BF
BF is COMPLEX*16 array, dimension (NMAX*NMAX)
X
X is COMPLEX*16 array, dimension (4*NMAX)
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
NIN
NIN is INTEGER
The unit number for input.
NOUT
NOUT is INTEGER
The unit number for output.
INFO
INFO is INTEGER
= 0 : successful exit
> 0 : If ZLATMS 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 zckgqr (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, complex*16, dimension( * ) A, complex*16,
dimension( * ) AF, complex*16, dimension( * ) AQ, complex*16, dimension( * ) AR,
complex*16, dimension( * ) TAUA, complex*16, dimension( * ) B, complex*16, dimension( * )
BF, complex*16, dimension( * ) BZ, complex*16, dimension( * ) BT, complex*16, dimension( *
) BWK, complex*16, dimension( * ) TAUB, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)
ZCKGQR
Purpose:
ZCKGQR tests
ZGGQRF: GQR factorization for N-by-M matrix A and N-by-P matrix B,
ZGGRQF: GRQ factorization for M-by-N matrix A and P-by-N matrix B.
Parameters:
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row(column) dimension M.
NP
NP is INTEGER
The number of values of P contained in the vector PVAL.
PVAL
PVAL is INTEGER array, dimension (NP)
The values of the matrix row(column) dimension P.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column(row) dimension N.
NMATS
NMATS 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.
ISEED
ISEED 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.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AF
AF is COMPLEX*16 array, dimension (NMAX*NMAX)
AQ
AQ is COMPLEX*16 array, dimension (NMAX*NMAX)
AR
AR is COMPLEX*16 array, dimension (NMAX*NMAX)
TAUA
TAUA is COMPLEX*16 array, dimension (NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NMAX)
BF
BF is COMPLEX*16 array, dimension (NMAX*NMAX)
BZ
BZ is COMPLEX*16 array, dimension (NMAX*NMAX)
BT
BT is COMPLEX*16 array, dimension (NMAX*NMAX)
BWK
BWK is COMPLEX*16 array, dimension (NMAX*NMAX)
TAUB
TAUB is COMPLEX*16 array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX)
NIN
NIN is INTEGER
The unit number for input.
NOUT
NOUT is INTEGER
The unit number for output.
INFO
INFO is INTEGER
= 0 : successful exit
> 0 : If ZLATMS 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 zckgsv (integer NM, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL,
integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double
precision THRESH, integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * )
AF, complex*16, dimension( * ) B, complex*16, dimension( * ) BF, complex*16, dimension( *
) U, complex*16, dimension( * ) V, complex*16, dimension( * ) Q, double precision,
dimension( * ) ALPHA, double precision, dimension( * ) BETA, complex*16, dimension( * ) R,
integer, dimension( * ) IWORK, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)
ZCKGSV
Purpose:
ZCKGSV tests ZGGSVD:
the GSVD for M-by-N matrix A and P-by-N matrix B.
Parameters:
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
PVAL
PVAL is INTEGER array, dimension (NP)
The values of the matrix row dimension P.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NMATS
NMATS 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.
ISEED
ISEED 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.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AF
AF is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NMAX)
BF
BF is COMPLEX*16 array, dimension (NMAX*NMAX)
U
U is COMPLEX*16 array, dimension (NMAX*NMAX)
V
V is COMPLEX*16 array, dimension (NMAX*NMAX)
Q
Q is COMPLEX*16 array, dimension (NMAX*NMAX)
ALPHA
ALPHA is DOUBLE PRECISION array, dimension (NMAX)
BETA
BETA is DOUBLE PRECISION array, dimension (NMAX)
R
R is COMPLEX*16 array, dimension (NMAX*NMAX)
IWORK
IWORK is INTEGER array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX)
NIN
NIN is INTEGER
The unit number for input.
NOUT
NOUT is INTEGER
The unit number for output.
INFO
INFO is INTEGER
= 0 : successful exit
> 0 : If ZLATMS 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 zcklse (integer NN, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL,
integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double
precision THRESH, integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * )
AF, complex*16, dimension( * ) B, complex*16, dimension( * ) BF, complex*16, dimension( *
) X, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN,
integer NOUT, integer INFO)
ZCKLSE
Purpose:
ZCKLSE tests ZGGLSE - 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).
MVAL
MVAL is INTEGER array, dimension (NN)
The values of the matrix row(column) dimension M.
PVAL
PVAL is INTEGER array, dimension (NN)
The values of the matrix row(column) dimension P.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column(row) dimension N.
NMATS
NMATS 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.
ISEED
ISEED 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.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AF
AF is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NMAX)
BF
BF is COMPLEX*16 array, dimension (NMAX*NMAX)
X
X is COMPLEX*16 array, dimension (5*NMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX)
NIN
NIN is INTEGER
The unit number for input.
NOUT
NOUT is INTEGER
The unit number for output.
INFO
INFO is INTEGER
= 0 : successful exit
> 0 : If ZLATMS 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 zcsdts (integer M, integer P, integer Q, complex*16, dimension( ldx, * ) X,
complex*16, dimension( ldx, * ) XF, integer LDX, complex*16, dimension( ldu1, * ) U1,
integer LDU1, complex*16, dimension( ldu2, * ) U2, integer LDU2, complex*16, dimension(
ldv1t, * ) V1T, integer LDV1T, complex*16, dimension( ldv2t, * ) V2T, integer LDV2T,
double precision, dimension( * ) THETA, integer, dimension( * ) IWORK, complex*16,
dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double
precision, dimension( 15 ) RESULT)
ZCSDTS
Purpose:
ZCSDTS tests ZUNCSD, which, given an M-by-M partitioned unitary
matrix X,
Q M-Q
X = [ X11 X12 ] P ,
[ X21 X22 ] M-P
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 SORCSD2BY1, which, given
Q
[ X11 ] P ,
[ X21 ] M-P
computes the 2-by-1 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.
P
P is INTEGER
The number of rows of the matrix X11. P >= 0.
Q
Q is INTEGER
The number of columns of the matrix X11. Q >= 0.
X
X is COMPLEX*16 array, dimension (LDX,M)
The M-by-M matrix X.
XF
XF is COMPLEX*16 array, dimension (LDX,M)
Details of the CSD of X, as returned by ZUNCSD;
see ZUNCSD for further details.
LDX
LDX is INTEGER
The leading dimension of the arrays X and XF.
LDX >= max( 1,M ).
U1
U1 is COMPLEX*16 array, dimension(LDU1,P)
The P-by-P unitary matrix U1.
LDU1
LDU1 is INTEGER
The leading dimension of the array U1. LDU >= max(1,P).
U2
U2 is COMPLEX*16 array, dimension(LDU2,M-P)
The (M-P)-by-(M-P) unitary matrix U2.
LDU2
LDU2 is INTEGER
The leading dimension of the array U2. LDU >= max(1,M-P).
V1T
V1T is COMPLEX*16 array, dimension(LDV1T,Q)
The Q-by-Q unitary matrix V1T.
LDV1T
LDV1T is INTEGER
The leading dimension of the array V1T. LDV1T >=
max(1,Q).
V2T
V2T is COMPLEX*16 array, dimension(LDV2T,M-Q)
The (M-Q)-by-(M-Q) unitary matrix V2T.
LDV2T
LDV2T is INTEGER
The leading dimension of the array V2T. LDV2T >=
max(1,M-Q).
THETA
THETA is DOUBLE PRECISION array, dimension MIN(P,M-P,Q,M-Q)
The CS values of X; the essentially diagonal matrices C and
S are constructed from THETA; see subroutine ZUNCSD for
details.
IWORK
IWORK is INTEGER array, dimension (M)
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK
RWORK
RWORK is DOUBLE PRECISION array
RESULT
RESULT is DOUBLE PRECISION array, dimension (15)
The test ratios:
First, the 2-by-2 CSD:
RESULT(1) = norm( U1'*X11*V1 - D11 ) / ( MAX(1,P,Q)*EPS2 )
RESULT(2) = norm( U1'*X12*V2 - D12 ) / ( MAX(1,P,M-Q)*EPS2 )
RESULT(3) = norm( U2'*X21*V1 - D21 ) / ( MAX(1,M-P,Q)*EPS2 )
RESULT(4) = norm( U2'*X22*V2 - D22 ) / ( MAX(1,M-P,M-Q)*EPS2 )
RESULT(5) = norm( I - U1'*U1 ) / ( MAX(1,P)*ULP )
RESULT(6) = norm( I - U2'*U2 ) / ( MAX(1,M-P)*ULP )
RESULT(7) = norm( I - V1T'*V1T ) / ( MAX(1,Q)*ULP )
RESULT(8) = norm( I - V2T'*V2T ) / ( MAX(1,M-Q)*ULP )
RESULT(9) = 0 if THETA is in increasing order and
all angles are in [0,pi/2];
= ULPINV otherwise.
Then, the 2-by-1 CSD:
RESULT(10) = norm( U1'*X11*V1 - D11 ) / ( MAX(1,P,Q)*EPS2 )
RESULT(11) = norm( U2'*X21*V1 - D21 ) / ( MAX(1,M-P,Q)*EPS2 )
RESULT(12) = norm( I - U1'*U1 ) / ( MAX(1,P)*ULP )
RESULT(13) = norm( I - U2'*U2 ) / ( MAX(1,M-P)*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 2015
subroutine zdrges (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
complex*16, dimension( lda, * ) S, complex*16, dimension( lda, * ) T, complex*16,
dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldq, * ) Z, complex*16,
dimension( * ) ALPHA, complex*16, dimension( * ) BETA, complex*16, dimension( * ) WORK,
integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 13 )
RESULT, logical, dimension( * ) BWORK, integer INFO)
ZDRGES
Purpose:
ZDRGES checks the nonsymmetric generalized eigenvalue (Schur form)
problem driver ZGGES.
ZGGES factors A and B as Q*S*Z' and Q*T*Z' , where ' means conjugate
transpose, S and T are upper triangular (i.e., in generalized Schur
form), and Q and Z are unitary. 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 ZDRGES 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. triangular form) (no sorting of
eigenvalues)
(6) if eigenvalues = diagonal elements of the Schur form (S, T),
i.e., test the maximum over j of D(j) where:
|alpha(j) - S(j,j)| |beta(j) - T(j,j)|
D(j) = ------------------------ + -----------------------
max(|alpha(j)|,|S(j,j)|) max(|beta(j)|,|T(j,j)|)
(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. quasi-triangular form)
(with sorting of eigenvalues).
(11) if eigenvalues = diagonal elements of the Schur form (S, T),
i.e. test the maximum over j of D(j) where:
|alpha(j) - S(j,j)| |beta(j) - T(j,j)|
D(j) = ------------------------ + -----------------------
max(|alpha(j)|,|S(j,j)|) max(|beta(j)|,|T(j,j)|)
(with sorting of eigenvalues).
(12) if sorting worked and SDIM is the number of eigenvalues
which were CELECTed.
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=(N-1)/2
(7) ( D, I ) where D is diag( 0, 1,..., N-1 ) (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, ..., N-3, 0 ) and
D2 is diag( 0, N-3, N-4,..., 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, ..., N-3, 0 ) and diag(T2) =
( 0, N-3, N-4,..., 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, 1-d, ..., 1-(N-5)*d=s, 0 )
diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 )
N-5
(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(N-4), 0 )
diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )
where r1,..., r(N-4) are random.
(22) Q ( big*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(23) Q ( small*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(24) Q ( small*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(25) Q ( big*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(26) Q ( T1, T2 ) Z where T1 and T2 are random upper-triangular
matrices.
Parameters:
NSIZES
NSIZES is INTEGER
The number of sizes of matrices to use. If it is zero,
DDRGES does nothing. NSIZES >= 0.
NN
NN is INTEGER array, dimension (NSIZES)
An array containing the sizes to be used for the matrices.
Zero values will be skipped. NN >= 0.
NTYPES
NTYPES 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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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.
THRESH
THRESH 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.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IINFO not equal to 0.)
A
A is COMPLEX*16 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.
LDA
LDA is INTEGER
The leading dimension of A, B, S, and T.
It must be at least 1 and at least max( NN ).
B
B is COMPLEX*16 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.
S
S is COMPLEX*16 array, dimension (LDA, max(NN))
The Schur form matrix computed from A by ZGGES. On exit, S
contains the Schur form matrix corresponding to the matrix
in A.
T
T is COMPLEX*16 array, dimension (LDA, max(NN))
The upper triangular matrix computed from B by ZGGES.
Q
Q is COMPLEX*16 array, dimension (LDQ, max(NN))
The (left) orthogonal matrix computed by ZGGES.
LDQ
LDQ is INTEGER
The leading dimension of Q and Z. It must
be at least 1 and at least max( NN ).
Z
Z is COMPLEX*16 array, dimension( LDQ, max(NN) )
The (right) orthogonal matrix computed by ZGGES.
ALPHA
ALPHA is COMPLEX*16 array, dimension (max(NN))
BETA
BETA is COMPLEX*16 array, dimension (max(NN))
The generalized eigenvalues of (A,B) computed by ZGGES.
ALPHA(k) / BETA(k) is the k-th generalized eigenvalue of A
and B.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK. LWORK >= 3*N*N.
RWORK
RWORK is DOUBLE PRECISION array, dimension ( 8*N )
Real workspace.
RESULT
RESULT 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.
BWORK
BWORK is LOGICAL array, dimension (N)
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th 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:
November 2011
subroutine zdrges3 (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
complex*16, dimension( lda, * ) S, complex*16, dimension( lda, * ) T, complex*16,
dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldq, * ) Z, complex*16,
dimension( * ) ALPHA, complex*16, dimension( * ) BETA, complex*16, dimension( * ) WORK,
integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 13 )
RESULT, logical, dimension( * ) BWORK, integer INFO)
ZDRGES3
Purpose:
ZDRGES3 checks the nonsymmetric generalized eigenvalue (Schur form)
problem driver ZGGES3.
ZGGES3 factors A and B as Q*S*Z' and Q*T*Z' , where ' means conjugate
transpose, S and T are upper triangular (i.e., in generalized Schur
form), and Q and Z are unitary. 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 ZDRGES3 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. triangular form) (no sorting of
eigenvalues)
(6) if eigenvalues = diagonal elements of the Schur form (S, T),
i.e., test the maximum over j of D(j) where:
|alpha(j) - S(j,j)| |beta(j) - T(j,j)|
D(j) = ------------------------ + -----------------------
max(|alpha(j)|,|S(j,j)|) max(|beta(j)|,|T(j,j)|)
(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. quasi-triangular form)
(with sorting of eigenvalues).
(11) if eigenvalues = diagonal elements of the Schur form (S, T),
i.e. test the maximum over j of D(j) where:
|alpha(j) - S(j,j)| |beta(j) - T(j,j)|
D(j) = ------------------------ + -----------------------
max(|alpha(j)|,|S(j,j)|) max(|beta(j)|,|T(j,j)|)
(with sorting of eigenvalues).
(12) if sorting worked and SDIM is the number of eigenvalues
which were CELECTed.
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=(N-1)/2
(7) ( D, I ) where D is diag( 0, 1,..., N-1 ) (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, ..., N-3, 0 ) and
D2 is diag( 0, N-3, N-4,..., 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, ..., N-3, 0 ) and diag(T2) =
( 0, N-3, N-4,..., 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, 1-d, ..., 1-(N-5)*d=s, 0 )
diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 )
N-5
(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(N-4), 0 )
diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )
where r1,..., r(N-4) are random.
(22) Q ( big*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(23) Q ( small*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(24) Q ( small*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(25) Q ( big*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(26) Q ( T1, T2 ) Z where T1 and T2 are random upper-triangular
matrices.
Parameters:
NSIZES
NSIZES is INTEGER
The number of sizes of matrices to use. If it is zero,
DDRGES3 does nothing. NSIZES >= 0.
NN
NN is INTEGER array, dimension (NSIZES)
An array containing the sizes to be used for the matrices.
Zero values will be skipped. NN >= 0.
NTYPES
NTYPES 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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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.
THRESH
THRESH 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.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IINFO not equal to 0.)
A
A is COMPLEX*16 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.
LDA
LDA is INTEGER
The leading dimension of A, B, S, and T.
It must be at least 1 and at least max( NN ).
B
B is COMPLEX*16 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.
S
S is COMPLEX*16 array, dimension (LDA, max(NN))
The Schur form matrix computed from A by ZGGES3. On exit, S
contains the Schur form matrix corresponding to the matrix
in A.
T
T is COMPLEX*16 array, dimension (LDA, max(NN))
The upper triangular matrix computed from B by ZGGES3.
Q
Q is COMPLEX*16 array, dimension (LDQ, max(NN))
The (left) orthogonal matrix computed by ZGGES3.
LDQ
LDQ is INTEGER
The leading dimension of Q and Z. It must
be at least 1 and at least max( NN ).
Z
Z is COMPLEX*16 array, dimension( LDQ, max(NN) )
The (right) orthogonal matrix computed by ZGGES3.
ALPHA
ALPHA is COMPLEX*16 array, dimension (max(NN))
BETA
BETA is COMPLEX*16 array, dimension (max(NN))
The generalized eigenvalues of (A,B) computed by ZGGES3.
ALPHA(k) / BETA(k) is the k-th generalized eigenvalue of A
and B.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK. LWORK >= 3*N*N.
RWORK
RWORK is DOUBLE PRECISION array, dimension ( 8*N )
Real workspace.
RESULT
RESULT 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.
BWORK
BWORK is LOGICAL array, dimension (N)
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th 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 zdrgev (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
complex*16, dimension( lda, * ) S, complex*16, dimension( lda, * ) T, complex*16,
dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldq, * ) Z, complex*16,
dimension( ldqe, * ) QE, integer LDQE, complex*16, dimension( * ) ALPHA, complex*16,
dimension( * ) BETA, complex*16, dimension( * ) ALPHA1, complex*16, dimension( * ) BETA1,
complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RWORK,
double precision, dimension( * ) RESULT, integer INFO)
ZDRGEV
Purpose:
ZDRGEV checks the nonsymmetric generalized eigenvalue problem driver
routine ZGGEV.
ZGGEV computes for a pair of n-by-n 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 conjugate-transpose of l.
When ZDRGEV 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 ZGGEV:
(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 conjugate-transpose of VL.
(2) | |VL(i)| - 1 | / ulp and whether largest component real
VL(i) denotes the i-th 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 i-th 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=(N-1)/2
(7) ( D, I ) where D is diag( 0, 1,..., N-1 ) (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, ..., N-3, 0 ) and
D2 is diag( 0, N-3, N-4,..., 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, ..., N-3, 0 ) and diag(T2) =
( 0, N-3, N-4,..., 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, 1-d, ..., 1-(N-5)*d=s, 0 )
diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 )
N-5
(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(N-4), 0 )
diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )
where r1,..., r(N-4) are random.
(22) Q ( big*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(23) Q ( small*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(24) Q ( small*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(25) Q ( big*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(26) Q ( T1, T2 ) Z where T1 and T2 are random upper-triangular
matrices.
Parameters:
NSIZES
NSIZES is INTEGER
The number of sizes of matrices to use. If it is zero,
ZDRGES does nothing. NSIZES >= 0.
NN
NN is INTEGER array, dimension (NSIZES)
An array containing the sizes to be used for the matrices.
Zero values will be skipped. NN >= 0.
NTYPES
NTYPES is INTEGER
The number of elements in DOTYPE. If it is zero, ZDRGEV
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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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 ZDRGES to continue the same random number
sequence.
THRESH
THRESH 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.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IERR not equal to 0.)
A
A is COMPLEX*16 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.
LDA
LDA is INTEGER
The leading dimension of A, B, S, and T.
It must be at least 1 and at least max( NN ).
B
B is COMPLEX*16 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.
S
S is COMPLEX*16 array, dimension (LDA, max(NN))
The Schur form matrix computed from A by ZGGEV. On exit, S
contains the Schur form matrix corresponding to the matrix
in A.
T
T is COMPLEX*16 array, dimension (LDA, max(NN))
The upper triangular matrix computed from B by ZGGEV.
Q
Q is COMPLEX*16 array, dimension (LDQ, max(NN))
The (left) eigenvectors matrix computed by ZGGEV.
LDQ
LDQ is INTEGER
The leading dimension of Q and Z. It must
be at least 1 and at least max( NN ).
Z
Z is COMPLEX*16 array, dimension( LDQ, max(NN) )
The (right) orthogonal matrix computed by ZGGEV.
QE
QE is COMPLEX*16 array, dimension( LDQ, max(NN) )
QE holds the computed right or left eigenvectors.
LDQE
LDQE is INTEGER
The leading dimension of QE. LDQE >= max(1,max(NN)).
ALPHA
ALPHA is COMPLEX*16 array, dimension (max(NN))
BETA
BETA is COMPLEX*16 array, dimension (max(NN))
The generalized eigenvalues of (A,B) computed by ZGGEV.
( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the k-th
generalized eigenvalue of A and B.
ALPHA1
ALPHA1 is COMPLEX*16 array, dimension (max(NN))
BETA1
BETA1 is COMPLEX*16 array, dimension (max(NN))
Like ALPHAR, ALPHAI, BETA, these arrays contain the
eigenvalues of A and B, but those computed when ZGGEV only
computes a partial eigendecomposition, i.e. not the
eigenvalues and left and right eigenvectors.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The number of entries in WORK. LWORK >= N*(N+1)
RWORK
RWORK is DOUBLE PRECISION array, dimension (8*N)
Real workspace.
RESULT
RESULT 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.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th 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:
November 2015
subroutine zdrgev3 (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
complex*16, dimension( lda, * ) S, complex*16, dimension( lda, * ) T, complex*16,
dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldq, * ) Z, complex*16,
dimension( ldqe, * ) QE, integer LDQE, complex*16, dimension( * ) ALPHA, complex*16,
dimension( * ) BETA, complex*16, dimension( * ) ALPHA1, complex*16, dimension( * ) BETA1,
complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RWORK,
double precision, dimension( * ) RESULT, integer INFO)
ZDRGEV3
Purpose:
ZDRGEV3 checks the nonsymmetric generalized eigenvalue problem driver
routine ZGGEV3.
ZGGEV3 computes for a pair of n-by-n 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 conjugate-transpose of l.
When ZDRGEV3 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 ZGGEV3:
(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 conjugate-transpose of VL.
(2) | |VL(i)| - 1 | / ulp and whether largest component real
VL(i) denotes the i-th 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 i-th 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=(N-1)/2
(7) ( D, I ) where D is diag( 0, 1,..., N-1 ) (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, ..., N-3, 0 ) and
D2 is diag( 0, N-3, N-4,..., 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, ..., N-3, 0 ) and diag(T2) =
( 0, N-3, N-4,..., 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, 1-d, ..., 1-(N-5)*d=s, 0 )
diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 )
N-5
(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(N-4), 0 )
diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )
where r1,..., r(N-4) are random.
(22) Q ( big*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(23) Q ( small*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(24) Q ( small*T1, small*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(25) Q ( big*T1, big*T2 ) Z diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
diag(T2) = ( 0, 1, ..., 1, 0, 0 )
(26) Q ( T1, T2 ) Z where T1 and T2 are random upper-triangular
matrices.
Parameters:
NSIZES
NSIZES is INTEGER
The number of sizes of matrices to use. If it is zero,
ZDRGEV3 does nothing. NSIZES >= 0.
NN
NN is INTEGER array, dimension (NSIZES)
An array containing the sizes to be used for the matrices.
Zero values will be skipped. NN >= 0.
NTYPES
NTYPES is INTEGER
The number of elements in DOTYPE. If it is zero, ZDRGEV3
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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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 ZDRGES to continue the same random number
sequence.
THRESH
THRESH 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.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IERR not equal to 0.)
A
A is COMPLEX*16 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.
LDA
LDA is INTEGER
The leading dimension of A, B, S, and T.
It must be at least 1 and at least max( NN ).
B
B is COMPLEX*16 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.
S
S is COMPLEX*16 array, dimension (LDA, max(NN))
The Schur form matrix computed from A by ZGGEV3. On exit, S
contains the Schur form matrix corresponding to the matrix
in A.
T
T is COMPLEX*16 array, dimension (LDA, max(NN))
The upper triangular matrix computed from B by ZGGEV3.
Q
Q is COMPLEX*16 array, dimension (LDQ, max(NN))
The (left) eigenvectors matrix computed by ZGGEV3.
LDQ
LDQ is INTEGER
The leading dimension of Q and Z. It must
be at least 1 and at least max( NN ).
Z
Z is COMPLEX*16 array, dimension( LDQ, max(NN) )
The (right) orthogonal matrix computed by ZGGEV3.
QE
QE is COMPLEX*16 array, dimension( LDQ, max(NN) )
QE holds the computed right or left eigenvectors.
LDQE
LDQE is INTEGER
The leading dimension of QE. LDQE >= max(1,max(NN)).
ALPHA
ALPHA is COMPLEX*16 array, dimension (max(NN))
BETA
BETA is COMPLEX*16 array, dimension (max(NN))
The generalized eigenvalues of (A,B) computed by ZGGEV3.
( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the k-th
generalized eigenvalue of A and B.
ALPHA1
ALPHA1 is COMPLEX*16 array, dimension (max(NN))
BETA1
BETA1 is COMPLEX*16 array, dimension (max(NN))
Like ALPHAR, ALPHAI, BETA, these arrays contain the
eigenvalues of A and B, but those computed when ZGGEV3 only
computes a partial eigendecomposition, i.e. not the
eigenvalues and left and right eigenvectors.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The number of entries in WORK. LWORK >= N*(N+1)
RWORK
RWORK is DOUBLE PRECISION array, dimension (8*N)
Real workspace.
RESULT
RESULT 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.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th 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:
Febuary 2015
subroutine zdrgsx (integer NSIZE, integer NCMAX, double precision THRESH, integer NIN, integer
NOUT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
complex*16, dimension( lda, * ) AI, complex*16, dimension( lda, * ) BI, complex*16,
dimension( lda, * ) Z, complex*16, dimension( lda, * ) Q, complex*16, dimension( * )
ALPHA, complex*16, dimension( * ) BETA, complex*16, dimension( ldc, * ) C, integer LDC,
double precision, dimension( * ) S, complex*16, dimension( * ) WORK, integer LWORK, double
precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer LIWORK, logical,
dimension( * ) BWORK, integer INFO)
ZDRGSX
Purpose:
ZDRGSX checks the nonsymmetric generalized eigenvalue (Schur form)
problem expert driver ZGGESX.
ZGGES factors A and B as Q*S*Z' and Q*T*Z' , where ' means conjugate
transpose, S and T are upper triangular (i.e., in generalized Schur
form), and Q and Z are unitary. 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 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 ZDRGSX is called with NSIZE > 0, five (5) types of built-in
matrix pairs are used to test the routine ZGGESX.
When ZDRGSX is called with NSIZE = 0, it reads in test matrix data
to test ZGGESX.
(need more details on what kind of read-in data are needed).
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. triangular form)
(6) maximum over j of D(j) where:
|alpha(j) - S(j,j)| |beta(j) - T(j,j)|
D(j) = ------------------------ + -----------------------
max(|alpha(j)|,|S(j,j)|) max(|beta(j)|,|T(j,j)|)
(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 ZGGESX, 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 read-in test matrices, the same tests are run except that the
exact value for DIF (and PL) is input data. Additionally, there is
one more test run for read-in 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 built-in tests, a total of 10*NSIZE*(NSIZE-1)
matrix pairs are generated and tested. NSIZE should be kept small.
SVD (routine ZGESVD) is used for computing the true value of DIF_u
and DIF_l when testing the built-in test problems.
Built-in Test Matrices
======================
All built-in 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(1-a,1).
B11 = I_m, B22 = I_k
where J_k(a,b) is the k-by-k Jordan block with ``a'' on
diagonal and ``b'' on superdiagonal.
Type 2: A11 = (a_ij) = ( 2(.5-sin(i)) ) and
B11 = (b_ij) = ( 2(.5-sin(ij)) ) for i=1,...,m, j=i,...,m
A22 = (a_ij) = ( 2(.5-sin(i+j)) ) and
B22 = (b_ij) = ( 2(.5-sin(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 |
| 1-d b |
| -b 1-d |
A_2 = | d 1+b |
| -1-b d |
| -d 1+b |
| -1+b -d |
| 1-d |
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 built-in tests matrices are used, but
read-in test matrices are used to test DGGESX.
NCMAX
NCMAX is INTEGER
Maximum allowable NMAX for generating Kroneker matrix
in call to ZLAKF2
THRESH
THRESH 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.
NIN
NIN is INTEGER
The FORTRAN unit number for reading in the data file of
problems to solve.
NOUT
NOUT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns INFO not equal to 0.)
A
A is COMPLEX*16 array, dimension (LDA, NSIZE)
Used to store the matrix whose eigenvalues are to be
computed. On exit, A contains the last matrix actually used.
LDA
LDA is INTEGER
The leading dimension of A, B, AI, BI, Z and Q,
LDA >= max( 1, NSIZE ). For the read-in test,
LDA >= max( 1, N ), N is the size of the test matrices.
B
B is COMPLEX*16 array, dimension (LDA, NSIZE)
Used to store the matrix whose eigenvalues are to be
computed. On exit, B contains the last matrix actually used.
AI
AI is COMPLEX*16 array, dimension (LDA, NSIZE)
Copy of A, modified by ZGGESX.
BI
BI is COMPLEX*16 array, dimension (LDA, NSIZE)
Copy of B, modified by ZGGESX.
Z
Z is COMPLEX*16 array, dimension (LDA, NSIZE)
Z holds the left Schur vectors computed by ZGGESX.
Q
Q is COMPLEX*16 array, dimension (LDA, NSIZE)
Q holds the right Schur vectors computed by ZGGESX.
ALPHA
ALPHA is COMPLEX*16 array, dimension (NSIZE)
BETA
BETA is COMPLEX*16 array, dimension (NSIZE)
On exit, ALPHA/BETA are the eigenvalues.
C
C is COMPLEX*16 array, dimension (LDC, LDC)
Store the matrix generated by subroutine ZLAKF2, this is the
matrix formed by Kronecker products used for estimating
DIF.
LDC
LDC is INTEGER
The leading dimension of C. LDC >= max(1, LDA*LDA/2 ).
S
S is DOUBLE PRECISION array, dimension (LDC)
Singular values of C
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK. LWORK >= 3*NSIZE*NSIZE/2
RWORK
RWORK is DOUBLE PRECISION array,
dimension (5*NSIZE*NSIZE/2 - 4)
IWORK
IWORK is INTEGER array, dimension (LIWORK)
LIWORK
LIWORK is INTEGER
The dimension of the array IWORK. LIWORK >= NSIZE + 2.
BWORK
BWORK is LOGICAL array, dimension (NSIZE)
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th 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:
November 2011
subroutine zdrgvx (integer NSIZE, double precision THRESH, integer NIN, integer NOUT,
complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
complex*16, dimension( lda, * ) AI, complex*16, dimension( lda, * ) BI, complex*16,
dimension( * ) ALPHA, complex*16, dimension( * ) BETA, complex*16, dimension( lda, * ) VL,
complex*16, 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, complex*16, dimension( * ) WORK, integer LWORK, double
precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer LIWORK, double
precision, dimension( 4 ) RESULT, logical, dimension( * ) BWORK, integer INFO)
ZDRGVX
Purpose:
ZDRGVX checks the nonsymmetric generalized eigenvalue problem
expert driver ZGGEVX.
ZGGEVX 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 ZDRGVX is called with NSIZE > 0, two types of test matrix pairs
are generated by the subroutine DLATM6 and test the driver ZGGEVX.
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 ZLATM6).
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 ZGGEVX
differs less than a factor THRESH from the exact S(i) (see
ZLATM6).
(4) DIF(i) computed by ZTGSNA 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 -1-b 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. If it is not zero, then N = 5.
THRESH
THRESH 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.
NIN
NIN is INTEGER
The FORTRAN unit number for reading in the data file of
problems to solve.
NOUT
NOUT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IINFO not equal to 0.)
A
A is COMPLEX*16 array, dimension (LDA, NSIZE)
Used to hold the matrix whose eigenvalues are to be
computed. On exit, A contains the last matrix actually used.
LDA
LDA is INTEGER
The leading dimension of A, B, AI, BI, Ao, and Bo.
It must be at least 1 and at least NSIZE.
B
B is COMPLEX*16 array, dimension (LDA, NSIZE)
Used to hold the matrix whose eigenvalues are to be
computed. On exit, B contains the last matrix actually used.
AI
AI is COMPLEX*16 array, dimension (LDA, NSIZE)
Copy of A, modified by ZGGEVX.
BI
BI is COMPLEX*16 array, dimension (LDA, NSIZE)
Copy of B, modified by ZGGEVX.
ALPHA
ALPHA is COMPLEX*16 array, dimension (NSIZE)
BETA
BETA is COMPLEX*16 array, dimension (NSIZE)
On exit, ALPHA/BETA are the eigenvalues.
VL
VL is COMPLEX*16 array, dimension (LDA, NSIZE)
VL holds the left eigenvectors computed by ZGGEVX.
VR
VR is COMPLEX*16 array, dimension (LDA, NSIZE)
VR holds the right eigenvectors computed by ZGGEVX.
ILO
ILO is INTEGER
IHI
IHI is INTEGER
LSCALE
LSCALE is DOUBLE PRECISION array, dimension (N)
RSCALE
RSCALE is DOUBLE PRECISION array, dimension (N)
S
S is DOUBLE PRECISION array, dimension (N)
DTRU
DTRU is DOUBLE PRECISION array, dimension (N)
DIF
DIF is DOUBLE PRECISION array, dimension (N)
DIFTRU
DIFTRU is DOUBLE PRECISION array, dimension (N)
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
Leading dimension of WORK. LWORK >= 2*N*N + 2*N
RWORK
RWORK is DOUBLE PRECISION array, dimension (6*N)
IWORK
IWORK is INTEGER array, dimension (LIWORK)
LIWORK
LIWORK is INTEGER
Leading dimension of IWORK. LIWORK >= N+2.
RESULT
RESULT is DOUBLE PRECISION array, dimension (4)
BWORK
BWORK is LOGICAL array, dimension (N)
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th 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:
November 2011
subroutine zdrvbd (integer NSIZES, integer, dimension( * ) MM, integer, dimension( * ) NN,
integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double
precision THRESH, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension(
ldu, * ) U, integer LDU, complex*16, dimension( ldvt, * ) VT, integer LDVT, complex*16,
dimension( lda, * ) ASAV, complex*16, dimension( ldu, * ) USAV, complex*16, dimension(
ldvt, * ) VTSAV, double precision, dimension( * ) S, double precision, dimension( * )
SSAV, double precision, dimension( * ) E, complex*16, dimension( * ) WORK, integer LWORK,
double precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUNIT,
integer INFO)
ZDRVBD
Purpose:
ZDRVBD checks the singular value decomposition (SVD) driver ZGESVD
and ZGESDD.
ZGESVD and ZGESDD factors A = U diag(S) VT, where U and VT are
unitary 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 ZDRVBD 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 ZGESVD:
(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 ZGESDD:
(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 ZGESVJ:
(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.)
Test for ZGEJSV:
(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.)
Test for ZGESVDX( 'V', 'V', 'A' )/ZGESVDX( 'N', 'N', 'A' )
(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 ZGESVDX( 'V', 'V', 'I' )
(8) | U' A VT''' - diag(S) | / ( |A| max(M,N) ulp )
(9) | I - U'U | / ( M ulp )
(10) | I - VT VT' | / ( N ulp )
Test for ZGESVDX( 'V', 'V', 'V' )
(11) | U' A VT''' - diag(S) | / ( |A| max(M,N) ulp )
(12) | I - U'U | / ( M ulp )
(13) | 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 unitary and
D has evenly spaced entries 1, ..., ULP with random signs
on the diagonal.
(4) Same as (3), but multiplied by the underflow-threshold / ULP.
(5) Same as (3), but multiplied by the overflow-threshold * ULP.
Parameters:
NSIZES
NSIZES is INTEGER
The number of sizes of matrices to use. If it is zero,
ZDRVBD does nothing. It must be at least zero.
MM
MM is INTEGER array, dimension (NSIZES)
An array containing the matrix "heights" to be used. For
each j=1,...,NSIZES, if MM(j) is zero, then MM(j) and NN(j)
will be ignored. The MM(j) values must be at least zero.
NN
NN is INTEGER array, dimension (NSIZES)
An array containing the matrix "widths" to be used. For
each j=1,...,NSIZES, if NN(j) is zero, then MM(j) and NN(j)
will be ignored. The NN(j) values must be at least zero.
NTYPES
NTYPES is INTEGER
The number of elements in DOTYPE. If it is zero, ZDRVBD
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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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 ZDRVBD to continue the same random number
sequence.
THRESH
THRESH 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.
A
A is COMPLEX*16 array, dimension (LDA,max(NN))
Used to hold the matrix whose singular values are to be
computed. On exit, A contains the last matrix actually
used.
LDA
LDA is INTEGER
The leading dimension of A. It must be at
least 1 and at least max( MM ).
U
U is COMPLEX*16 array, dimension (LDU,max(MM))
Used to hold the computed matrix of right singular vectors.
On exit, U contains the last such vectors actually computed.
LDU
LDU is INTEGER
The leading dimension of U. It must be at
least 1 and at least max( MM ).
VT
VT is COMPLEX*16 array, dimension (LDVT,max(NN))
Used to hold the computed matrix of left singular vectors.
On exit, VT contains the last such vectors actually computed.
LDVT
LDVT is INTEGER
The leading dimension of VT. It must be at
least 1 and at least max( NN ).
ASAV
ASAV is COMPLEX*16 array, dimension (LDA,max(NN))
Used to hold a different copy of the matrix whose singular
values are to be computed. On exit, A contains the last
matrix actually used.
USAV
USAV is COMPLEX*16 array, dimension (LDU,max(MM))
Used to hold a different copy of the computed matrix of
right singular vectors. On exit, USAV contains the last such
vectors actually computed.
VTSAV
VTSAV is COMPLEX*16 array, dimension (LDVT,max(NN))
Used to hold a different copy of the computed matrix of
left singular vectors. On exit, VTSAV contains the last such
vectors actually computed.
S
S is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
Contains the computed singular values.
SSAV
SSAV is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
Contains another copy of the computed singular values.
E
E is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
Workspace for ZGESVD.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The number of entries in WORK. This must be at least
MAX(3*MIN(M,N)+MAX(M,N)**2,5*MIN(M,N),3*MAX(M,N)) for all
pairs (M,N)=(MM(j),NN(j))
RWORK
RWORK is DOUBLE PRECISION array,
dimension ( 5*max(max(MM,NN)) )
IWORK
IWORK is INTEGER array, dimension at least 8*min(M,N)
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns IINFO not equal to 0.)
INFO
INFO 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 ZLATMS, or ZGESVD 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 zdrves (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) H,
complex*16, dimension( lda, * ) HT, complex*16, dimension( * ) W, complex*16, dimension( *
) WT, complex*16, dimension( ldvs, * ) VS, integer LDVS, double precision, dimension( 13 )
RESULT, complex*16, dimension( * ) WORK, integer NWORK, double precision, dimension( * )
RWORK, integer, dimension( * ) IWORK, logical, dimension( * ) BWORK, integer INFO)
ZDRVES
Purpose:
ZDRVES checks the nonsymmetric eigenvalue (Schur form) problem
driver ZGEES.
When ZDRVES 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 W 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 W 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 complex angles.
(ULP = (first number larger than 1) - 1 )
(5) A diagonal matrix with geometrically spaced entries
1, ..., ULP and random complex angles.
(6) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
and random complex angles.
(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 unitary and
T has evenly spaced entries 1, ..., ULP with random
complex angles on the diagonal and random O(1) entries in
the upper triangle.
(10) A matrix of the form U' T U, where U is unitary and
T has geometrically spaced entries 1, ..., ULP with random
complex angles 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
complex angles on the diagonal and random O(1) entries in
the upper triangle.
(12) A matrix of the form U' T U, where U is unitary and
T has complex eigenvalues randomly chosen from
ULP < |z| < 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 complex angles 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 complex angles 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 complex angles 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 complex eigenvalues randomly chosen
from ULP < |z| < 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,
ZDRVES does nothing. It must be at least zero.
NN
NN 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.
NTYPES
NTYPES is INTEGER
The number of elements in DOTYPE. If it is zero, ZDRVES
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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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 ZDRVES to continue the same random number
sequence.
THRESH
THRESH 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.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns INFO not equal to 0.)
A
A is COMPLEX*16 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.
LDA
LDA is INTEGER
The leading dimension of A, and H. LDA must be at
least 1 and at least max( NN ).
H
H is COMPLEX*16 array, dimension (LDA, max(NN))
Another copy of the test matrix A, modified by ZGEES.
HT
HT is COMPLEX*16 array, dimension (LDA, max(NN))
Yet another copy of the test matrix A, modified by ZGEES.
W
W is COMPLEX*16 array, dimension (max(NN))
The computed eigenvalues of A.
WT
WT is COMPLEX*16 array, dimension (max(NN))
Like W, this array contains the eigenvalues of A,
but those computed when ZGEES only computes a partial
eigendecomposition, i.e. not Schur vectors
VS
VS is COMPLEX*16 array, dimension (LDVS, max(NN))
VS holds the computed Schur vectors.
LDVS
LDVS is INTEGER
Leading dimension of VS. Must be at least max(1,max(NN)).
RESULT
RESULT 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.
WORK
WORK is COMPLEX*16 array, dimension (NWORK)
NWORK
NWORK is INTEGER
The number of entries in WORK. This must be at least
5*NN(j)+2*NN(j)**2 for all j.
RWORK
RWORK is DOUBLE PRECISION array, dimension (max(NN))
IWORK
IWORK is INTEGER array, dimension (max(NN))
BWORK
BWORK is LOGICAL array, dimension (max(NN))
INFO
INFO 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) ).
-15: LDVS < 1 or LDVS < NMAX, where NMAX is max( NN(j) ).
-18: NWORK too small.
If ZLATMR, CLATMS, CLATME or ZGEES 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 (1-10) 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) Select 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 zdrvev (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) H,
complex*16, dimension( * ) W, complex*16, dimension( * ) W1, complex*16, dimension( ldvl,
* ) VL, integer LDVL, complex*16, dimension( ldvr, * ) VR, integer LDVR, complex*16,
dimension( ldlre, * ) LRE, integer LDLRE, double precision, dimension( 7 ) RESULT,
complex*16, dimension( * ) WORK, integer NWORK, double precision, dimension( * ) RWORK,
integer, dimension( * ) IWORK, integer INFO)
ZDRVEV
Purpose:
ZDRVEV checks the nonsymmetric eigenvalue problem driver ZGEEV.
When ZDRVEV 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 diagonal matrix with diagonal entries W(j).
(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 i-th column of VR.
(4) | |VL(i)| - 1 | / ulp and whether largest component real
VL(i) denotes the i-th 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 complex angles.
(ULP = (first number larger than 1) - 1 )
(5) A diagonal matrix with geometrically spaced entries
1, ..., ULP and random complex angles.
(6) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
and random complex angles.
(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 unitary and
T has evenly spaced entries 1, ..., ULP with random complex
angles on the diagonal and random O(1) entries in the upper
triangle.
(10) A matrix of the form U' T U, where U is unitary and
T has geometrically spaced entries 1, ..., ULP with random
complex angles on the diagonal and random O(1) entries in
the upper triangle.
(11) A matrix of the form U' T U, where U is unitary and
T has "clustered" entries 1, ULP,..., ULP with random
complex angles on the diagonal and random O(1) entries in
the upper triangle.
(12) A matrix of the form U' T U, where U is unitary and
T has complex eigenvalues randomly chosen from
ULP < |z| < 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 complex angles 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 complex angles 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 complex angles 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 complex eigenvalues randomly chosen
from ULP < |z| < 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 |z| < 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,
ZDRVEV does nothing. It must be at least zero.
NN
NN 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.
NTYPES
NTYPES is INTEGER
The number of elements in DOTYPE. If it is zero, ZDRVEV
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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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 ZDRVEV to continue the same random number
sequence.
THRESH
THRESH 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.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns INFO not equal to 0.)
A
A is COMPLEX*16 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.
LDA
LDA is INTEGER
The leading dimension of A, and H. LDA must be at
least 1 and at least max(NN).
H
H is COMPLEX*16 array, dimension (LDA, max(NN))
Another copy of the test matrix A, modified by ZGEEV.
W
W is COMPLEX*16 array, dimension (max(NN))
The eigenvalues of A. On exit, W are the eigenvalues of
the matrix in A.
W1
W1 is COMPLEX*16 array, dimension (max(NN))
Like W, this array contains the eigenvalues of A,
but those computed when ZGEEV only computes a partial
eigendecomposition, i.e. not the eigenvalues and left
and right eigenvectors.
VL
VL is COMPLEX*16 array, dimension (LDVL, max(NN))
VL holds the computed left eigenvectors.
LDVL
LDVL is INTEGER
Leading dimension of VL. Must be at least max(1,max(NN)).
VR
VR is COMPLEX*16 array, dimension (LDVR, max(NN))
VR holds the computed right eigenvectors.
LDVR
LDVR is INTEGER
Leading dimension of VR. Must be at least max(1,max(NN)).
LRE
LRE is COMPLEX*16 array, dimension (LDLRE, max(NN))
LRE holds the computed right or left eigenvectors.
LDLRE
LDLRE is INTEGER
Leading dimension of LRE. Must be at least max(1,max(NN)).
RESULT
RESULT 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.
WORK
WORK is COMPLEX*16 array, dimension (NWORK)
NWORK
NWORK is INTEGER
The number of entries in WORK. This must be at least
5*NN(j)+2*NN(j)**2 for all j.
RWORK
RWORK is DOUBLE PRECISION array, dimension (2*max(NN))
IWORK
IWORK is INTEGER array, dimension (max(NN))
INFO
INFO 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) ).
-14: LDVL < 1 or LDVL < NMAX, where NMAX is max( NN(j) ).
-16: LDVR < 1 or LDVR < NMAX, where NMAX is max( NN(j) ).
-18: LDLRE < 1 or LDLRE < NMAX, where NMAX is max( NN(j) ).
-21: NWORK too small.
If ZLATMR, CLATMS, CLATME or ZGEEV 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 (1-10) 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 zdrvsg (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B,
integer LDB, double precision, dimension( * ) D, complex*16, dimension( ldz, * ) Z,
integer LDZ, complex*16, dimension( lda, * ) AB, complex*16, dimension( ldb, * ) BB,
complex*16, dimension( * ) AP, complex*16, dimension( * ) BP, complex*16, dimension( * )
WORK, integer NWORK, double precision, dimension( * ) RWORK, integer LRWORK, integer,
dimension( * ) IWORK, integer LIWORK, double precision, dimension( * ) RESULT, integer
INFO)
ZDRVSG
Purpose:
ZDRVSG checks the complex Hermitian generalized eigenproblem
drivers.
ZHEGV computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian-definite generalized
eigenproblem.
ZHEGVD computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian-definite generalized
eigenproblem using a divide and conquer algorithm.
ZHEGVX computes selected eigenvalues and, optionally,
eigenvectors of a complex Hermitian-definite generalized
eigenproblem.
ZHPGV computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian-definite generalized
eigenproblem in packed storage.
ZHPGVD computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian-definite generalized
eigenproblem in packed storage using a divide and
conquer algorithm.
ZHPGVX computes selected eigenvalues and, optionally,
eigenvectors of a complex Hermitian-definite generalized
eigenproblem in packed storage.
ZHBGV computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian-definite banded
generalized eigenproblem.
ZHBGVD computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian-definite banded
generalized eigenproblem using a divide and conquer
algorithm.
ZHBGVX computes selected eigenvalues and, optionally,
eigenvectors of a complex Hermitian-definite banded
generalized eigenproblem.
When ZDRVSG 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 well-conditioned 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) ZHEGV with ITYPE = 1 and UPLO ='U':
| A Z - B Z D | / ( |A| |Z| n ulp )
(2) as (1) but calling ZHPGV
(3) as (1) but calling ZHBGV
(4) as (1) but with UPLO = 'L'
(5) as (4) but calling ZHPGV
(6) as (4) but calling ZHBGV
(7) ZHEGV with ITYPE = 2 and UPLO ='U':
| A B Z - Z D | / ( |A| |Z| n ulp )
(8) as (7) but calling ZHPGV
(9) as (7) but with UPLO = 'L'
(10) as (9) but calling ZHPGV
(11) ZHEGV with ITYPE = 3 and UPLO ='U':
| B A Z - Z D | / ( |A| |Z| n ulp )
(12) as (11) but calling ZHPGV
(13) as (11) but with UPLO = 'L'
(14) as (13) but calling ZHPGV
ZHEGVD, ZHPGVD and ZHBGVD performed the same 14 tests.
ZHEGVX, ZHPGVX and ZHBGVX 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 half-bandwidth KA.
B is generated as a well-conditioned positive definite matrix
with half-bandwidth 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 unitary 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 unitary 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 unitary 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) Hermitian 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,
ZDRVSG 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, ZDRVSG
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 ZDRVSG 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 COMPLEX*16 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.
B COMPLEX*16 array, dimension (LDB , max(NN))
Used to hold the Hermitian positive definite matrix for
the generailzed problem.
On exit, B contains the last matrix actually
used.
Modified.
LDB INTEGER
The leading dimension of B. 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 COMPLEX*16 array, dimension (LDZ, max(NN))
The matrix of eigenvectors.
Modified.
LDZ INTEGER
The leading dimension of ZZ. It must be at least 1 and
at least max( NN ).
Not modified.
AB COMPLEX*16 array, dimension (LDA, max(NN))
Workspace.
Modified.
BB COMPLEX*16 array, dimension (LDB, max(NN))
Workspace.
Modified.
AP COMPLEX*16 array, dimension (max(NN)**2)
Workspace.
Modified.
BP COMPLEX*16 array, dimension (max(NN)**2)
Workspace.
Modified.
WORK COMPLEX*16 array, dimension (NWORK)
Workspace.
Modified.
NWORK INTEGER
The number of entries in WORK. This must be at least
2*N + N**2 where N = max( NN(j), 2 ).
Not modified.
RWORK DOUBLE PRECISION array, dimension (LRWORK)
Workspace.
Modified.
LRWORK INTEGER
The number of entries in RWORK. This must be at least
max( 7*N, 1 + 4*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 IWORK. This must be at least
2 + 5*max( NN(j) ).
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: LRWORK too small.
-25: LIWORK too small.
If ZLATMR, CLATMS, ZHEGV, ZHPGV, ZHBGV, CHEGVD, CHPGVD,
ZHPGVD, ZHEGVX, CHPGVX, ZHBGVX 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 (1-10) 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 zdrvst (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, double precision, dimension( * )
D1, double precision, dimension( * ) D2, double precision, dimension( * ) D3, double
precision, dimension( * ) WA1, double precision, dimension( * ) WA2, double precision,
dimension( * ) WA3, complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension(
ldu, * ) V, complex*16, dimension( * ) TAU, complex*16, dimension( ldu, * ) Z, complex*16,
dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RWORK, integer
LRWORK, integer, dimension( * ) IWORK, integer LIWORK, double precision, dimension( * )
RESULT, integer INFO)
ZDRVST
Purpose:
ZDRVST checks the Hermitian eigenvalue problem drivers.
ZHEEVD computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian matrix,
using a divide-and-conquer algorithm.
ZHEEVX computes selected eigenvalues and, optionally,
eigenvectors of a complex Hermitian matrix.
ZHEEVR computes selected eigenvalues and, optionally,
eigenvectors of a complex Hermitian matrix
using the Relatively Robust Representation where it can.
ZHPEVD computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian matrix in packed
storage, using a divide-and-conquer algorithm.
ZHPEVX computes selected eigenvalues and, optionally,
eigenvectors of a complex Hermitian matrix in packed
storage.
ZHBEVD computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian band matrix,
using a divide-and-conquer algorithm.
ZHBEVX computes selected eigenvalues and, optionally,
eigenvectors of a complex Hermitian band matrix.
ZHEEV computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian matrix.
ZHPEV computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian matrix in packed
storage.
ZHBEV computes all eigenvalues and, optionally,
eigenvectors of a complex Hermitian band matrix.
When ZDRVST 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 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 unitary 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 unitary 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 unitary 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 N-1, 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,
ZDRVST 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, ZDRVST
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 ZDRVST 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 COMPLEX*16 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 ZSTEQR 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 ZSTEQR 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.
WA1 DOUBLE PRECISION array, dimension
WA2 DOUBLE PRECISION array, dimension
WA3 DOUBLE PRECISION array, dimension
U COMPLEX*16 array, dimension (LDU, max(NN))
The unitary matrix computed by ZHETRD + ZUNGC3.
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 COMPLEX*16 array, dimension (LDU, max(NN))
The Housholder vectors computed by ZHETRD in reducing A to
tridiagonal form.
Modified.
TAU COMPLEX*16 array, dimension (max(NN))
The Householder factors computed by ZHETRD in reducing A
to tridiagonal form.
Modified.
Z COMPLEX*16 array, dimension (LDU, max(NN))
The unitary matrix of eigenvectors computed by ZHEEVD,
ZHEEVX, ZHPEVD, CHPEVX, ZHBEVD, and CHBEVX.
Modified.
WORK - COMPLEX*16 array of dimension ( LWORK )
Workspace.
Modified.
LWORK - INTEGER
The number of entries in WORK. This must be at least
2*max( NN(j), 2 )**2.
Not modified.
RWORK DOUBLE PRECISION array, dimension (3*max(NN))
Workspace.
Modified.
LRWORK - INTEGER
The number of entries in RWORK.
IWORK INTEGER array, dimension (6*max(NN))
Workspace.
Modified.
LIWORK - INTEGER
The number of entries in IWORK.
RESULT DOUBLE PRECISION array, dimension (??)
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, SLATMS, ZHETRD, DORGC3, ZSTEQR, DSTERF,
or DORMC2 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 (1-10) 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 zdrvsx (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NIUNIT, integer NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16,
dimension( lda, * ) H, complex*16, dimension( lda, * ) HT, complex*16, dimension( * ) W,
complex*16, dimension( * ) WT, complex*16, dimension( * ) WTMP, complex*16, dimension(
ldvs, * ) VS, integer LDVS, complex*16, dimension( ldvs, * ) VS1, double precision,
dimension( 17 ) RESULT, complex*16, dimension( * ) WORK, integer LWORK, double precision,
dimension( * ) RWORK, logical, dimension( * ) BWORK, integer INFO)
ZDRVSX
Purpose:
ZDRVSX checks the nonsymmetric eigenvalue (Schur form) problem
expert driver ZGEESX.
ZDRVSX 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 ZDRVSX 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 W 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 W are eigenvalues of T
1/ulp otherwise
If workspace sufficient, also compare W 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 complex angles.
(ULP = (first number larger than 1) - 1 )
(5) A diagonal matrix with geometrically spaced entries
1, ..., ULP and random complex angles.
(6) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
and random complex angles.
(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 unitary and
T has evenly spaced entries 1, ..., ULP with random
complex angles on the diagonal and random O(1) entries in
the upper triangle.
(10) A matrix of the form U' T U, where U is unitary and
T has geometrically spaced entries 1, ..., ULP with random
complex angles 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
complex angles on the diagonal and random O(1) entries in
the upper triangle.
(12) A matrix of the form U' T U, where U is unitary and
T has complex eigenvalues randomly chosen from
ULP < |z| < 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 complex angles 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 complex angles 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 complex angles 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 complex eigenvalues randomly chosen
from ULP < |z| < 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 ZGEESX 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 ZGEESX 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.
NN
NN 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.
NTYPES
NTYPES 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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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 ZDRVSX to continue the same random number
sequence.
THRESH
THRESH 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.
NIUNIT
NIUNIT is INTEGER
The FORTRAN unit number for reading in the data file of
problems to solve.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns INFO not equal to 0.)
A
A is COMPLEX*16 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.
LDA
LDA is INTEGER
The leading dimension of A, and H. LDA must be at
least 1 and at least max( NN ).
H
H is COMPLEX*16 array, dimension (LDA, max(NN))
Another copy of the test matrix A, modified by ZGEESX.
HT
HT is COMPLEX*16 array, dimension (LDA, max(NN))
Yet another copy of the test matrix A, modified by ZGEESX.
W
W is COMPLEX*16 array, dimension (max(NN))
The computed eigenvalues of A.
WT
WT is COMPLEX*16 array, dimension (max(NN))
Like W, this array contains the eigenvalues of A,
but those computed when ZGEESX only computes a partial
eigendecomposition, i.e. not Schur vectors
WTMP
WTMP is COMPLEX*16 array, dimension (max(NN))
More temporary storage for eigenvalues.
VS
VS is COMPLEX*16 array, dimension (LDVS, max(NN))
VS holds the computed Schur vectors.
LDVS
LDVS is INTEGER
Leading dimension of VS. Must be at least max(1,max(NN)).
VS1
VS1 is COMPLEX*16 array, dimension (LDVS, max(NN))
VS1 holds another copy of the computed Schur vectors.
RESULT
RESULT 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.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The number of entries in WORK. This must be at least
max(1,2*NN(j)**2) for all j.
RWORK
RWORK is DOUBLE PRECISION array, dimension (max(NN))
BWORK
BWORK is LOGICAL array, dimension (max(NN))
INFO
INFO is INTEGER
If 0, successful exit.
<0, input parameter -INFO is incorrect
>0, ZLATMR, CLATMS, CLATME or ZGET24 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 (1-10) 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 zdrvvx (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
NIUNIT, integer NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16,
dimension( lda, * ) H, complex*16, dimension( * ) W, complex*16, dimension( * ) W1,
complex*16, dimension( ldvl, * ) VL, integer LDVL, complex*16, dimension( ldvr, * ) VR,
integer LDVR, complex*16, 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, complex*16, dimension( * ) WORK, integer NWORK, double precision,
dimension( * ) RWORK, integer INFO)
ZDRVVX
Purpose:
ZDRVVX checks the nonsymmetric eigenvalue problem expert driver
ZGEEVX.
ZDRVVX 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 ZDRVVX 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 diagonal matrix with diagonal entries W(j).
(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 i-th column of VR.
(4) | |VL(i)| - 1 | / ulp and largest component real
VL(i) denotes the i-th 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 complex angles.
(ULP = (first number larger than 1) - 1 )
(5) A diagonal matrix with geometrically spaced entries
1, ..., ULP and random complex angles.
(6) A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
and random complex angles.
(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 unitary and
T has evenly spaced entries 1, ..., ULP with random complex
angles on the diagonal and random O(1) entries in the upper
triangle.
(10) A matrix of the form U' T U, where U is unitary and
T has geometrically spaced entries 1, ..., ULP with random
complex angles on the diagonal and random O(1) entries in
the upper triangle.
(11) A matrix of the form U' T U, where U is unitary and
T has "clustered" entries 1, ULP,..., ULP with random
complex angles on the diagonal and random O(1) entries in
the upper triangle.
(12) A matrix of the form U' T U, where U is unitary and
T has complex eigenvalues randomly chosen from
ULP < |z| < 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 complex angles 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 complex angles 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 complex angles 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 complex eigenvalues randomly chosen
from ULP < |z| < 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 |z| < 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 ZGEEVX 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 ZGEEVX 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.
NN
NN 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.
NTYPES
NTYPES 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. .
DOTYPE
DOTYPE 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.
ISEED
ISEED 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 ZDRVVX to continue the same random number
sequence.
THRESH
THRESH 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.
NIUNIT
NIUNIT is INTEGER
The FORTRAN unit number for reading in the data file of
problems to solve.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns INFO not equal to 0.)
A
A is COMPLEX*16 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.
LDA
LDA is INTEGER
The leading dimension of A, and H. LDA must be at
least 1 and at least max( NN, 12 ). (12 is the
dimension of the largest matrix on the precomputed
input file.)
H
H is COMPLEX*16 array, dimension (LDA, max(NN,12))
Another copy of the test matrix A, modified by ZGEEVX.
W
W is COMPLEX*16 array, dimension (max(NN,12))
Contains the eigenvalues of A.
W1
W1 is COMPLEX*16 array, dimension (max(NN,12))
Like W, this array contains the eigenvalues of A,
but those computed when ZGEEVX only computes a partial
eigendecomposition, i.e. not the eigenvalues and left
and right eigenvectors.
VL
VL is COMPLEX*16 array, dimension (LDVL, max(NN,12))
VL holds the computed left eigenvectors.
LDVL
LDVL is INTEGER
Leading dimension of VL. Must be at least max(1,max(NN,12)).
VR
VR is COMPLEX*16 array, dimension (LDVR, max(NN,12))
VR holds the computed right eigenvectors.
LDVR
LDVR is INTEGER
Leading dimension of VR. Must be at least max(1,max(NN,12)).
LRE
LRE is COMPLEX*16 array, dimension (LDLRE, max(NN,12))
LRE holds the computed right or left eigenvectors.
LDLRE
LDLRE is INTEGER
Leading dimension of LRE. Must be at least max(1,max(NN,12))
RCONDV
RCONDV is DOUBLE PRECISION array, dimension (N)
RCONDV holds the computed reciprocal condition numbers
for eigenvectors.
RCNDV1
RCNDV1 is DOUBLE PRECISION array, dimension (N)
RCNDV1 holds more computed reciprocal condition numbers
for eigenvectors.
RCDVIN
RCDVIN is DOUBLE PRECISION array, dimension (N)
When COMP = .TRUE. RCDVIN holds the precomputed reciprocal
condition numbers for eigenvectors to be compared with
RCONDV.
RCONDE
RCONDE is DOUBLE PRECISION array, dimension (N)
RCONDE holds the computed reciprocal condition numbers
for eigenvalues.
RCNDE1
RCNDE1 is DOUBLE PRECISION array, dimension (N)
RCNDE1 holds more computed reciprocal condition numbers
for eigenvalues.
RCDEIN
RCDEIN is DOUBLE PRECISION array, dimension (N)
When COMP = .TRUE. RCDEIN holds the precomputed reciprocal
condition numbers for eigenvalues to be compared with
RCONDE.
SCALE
SCALE is DOUBLE PRECISION array, dimension (N)
Holds information describing balancing of matrix.
SCALE1
SCALE1 is DOUBLE PRECISION array, dimension (N)
Holds information describing balancing of matrix.
WORK
WORK is COMPLEX*16 array, dimension (NWORK)
RESULT
RESULT 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.
NWORK
NWORK 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.
RWORK
RWORK is DOUBLE PRECISION array, dimension (2*max(NN,12))
INFO
INFO is INTEGER
If 0, then successful exit.
If <0, then input parameter -INFO is incorrect.
If >0, ZLATMR, CLATMS, CLATME or ZGET23 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 (1-10) 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 zerrbd (character*3 PATH, integer NUNIT)
ZERRBD
Purpose:
ZERRBD tests the error exits for ZGEBRD, ZUNGBR, ZUNMBR, and ZBDSQR.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrec (character*3 PATH, integer NUNIT)
ZERREC
Purpose:
ZERREC tests the error exits for the routines for eigen- condition
estimation for DOUBLE PRECISION matrices:
ZTRSYL, CTREXC, CTRSNA and CTRSEN.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerred (character*3 PATH, integer NUNIT)
ZERRED
Purpose:
ZERRED tests the error exits for the eigenvalue driver routines for
DOUBLE COMPLEX PRECISION matrices:
PATH driver description
---- ------ -----------
ZEV ZGEEV find eigenvalues/eigenvectors for nonsymmetric A
ZES ZGEES find eigenvalues/Schur form for nonsymmetric A
ZVX ZGEEVX ZGEEV + balancing and condition estimation
ZSX ZGEESX ZGEES + balancing and condition estimation
ZBD ZGESVD compute SVD of an M-by-N matrix A
ZGESDD compute SVD of an M-by-N matrix A(by divide and
conquer)
ZGEJSV compute SVD of an M-by-N matrix A where M >= N
ZGESVDX compute SVD of an M-by-N matrix A(by bisection
and inverse iteration)
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zerrgg (character*3 PATH, integer NUNIT)
ZERRGG
Purpose:
ZERRGG tests the error exits for ZGGES, ZGGESX, ZGGEV, ZGGEVX,
ZGGES3, ZGGEV3, ZGGGLM, ZGGHRD, ZGGLSE, ZGGQRF, ZGGRQF,
ZGGSVD3, ZGGSVP3, ZHGEQZ, ZTGEVC, ZTGEXC, ZTGSEN, ZTGSJA,
ZTGSNA, ZTGSYL, and ZUNCSD.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zerrhs (character*3 PATH, integer NUNIT)
ZERRHS
Purpose:
ZERRHS tests the error exits for ZGEBAK, CGEBAL, CGEHRD, ZUNGHR,
ZUNMHR, ZHSEQR, CHSEIN, and ZTREVC.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrst (character*3 PATH, integer NUNIT)
ZERRST
Purpose:
ZERRST tests the error exits for ZHETRD, ZUNGTR, CUNMTR, ZHPTRD,
ZUNGTR, ZUPMTR, ZSTEQR, CSTEIN, ZPTEQR, ZHBTRD,
ZHEEV, CHEEVX, CHEEVD, ZHBEV, CHBEVX, CHBEVD,
ZHPEV, CHPEVX, CHPEVD, and ZSTEDC.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zget02 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension(
lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double
precision RESID)
ZGET02
Purpose:
ZGET02 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^T*x = b, where A^T is the transpose of A
= 'C': A^H*x = b, where A^H is the conjugate transpose of A
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original M x N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,M).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. IF TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESID
RESID 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 zget10 (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double
precision, dimension( * ) RWORK, double precision RESULT)
ZGET10
Purpose:
ZGET10 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.
N
N is INTEGER
The number of columns of the matrices A and B.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m by n matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,M).
B
B is COMPLEX*16 array, dimension (LDB,N)
The m by n matrix B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,M).
WORK
WORK is COMPLEX*16 array, dimension (M)
RWORK
RWORK is COMPLEX*16 array, dimension (M)
RESULT
RESULT 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 zget22 (character TRANSA, character TRANSE, character TRANSW, integer N,
complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lde, * ) E, integer
LDE, complex*16, dimension( * ) W, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
ZGET22
Purpose:
ZGET22 does an eigenvector check.
The basic test is:
RESULT(1) = | A E - E W | / ( |A| |E| ulp )
using the 1-norm. It also tests the normalization of E:
RESULT(2) = max | m-norm(E(j)) - 1 | / ( n ulp )
j
where E(j) is the j-th eigenvector, and m-norm is the max-norm of a
vector. The max-norm of a complex n-vector x in this case is the
maximum of |re(x(i)| + |im(x(i)| over i = 1, ..., n.
Parameters:
TRANSA
TRANSA is CHARACTER*1
Specifies whether or not A is transposed.
= 'N': No transpose
= 'T': Transpose
= 'C': Conjugate transpose
TRANSE
TRANSE 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, eigenvectors are in rows of E
TRANSW
TRANSW is CHARACTER*1
Specifies whether or not W is transposed.
= 'N': No transpose
= 'T': Transpose, same as TRANSW = 'N'
= 'C': Conjugate transpose, use -WI(j) instead of WI(j)
N
N is INTEGER
The order of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The matrix whose eigenvectors are in E.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
E
E is COMPLEX*16 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.
LDE
LDE is INTEGER
The leading dimension of the array E. LDE >= max(1,N).
W
W is COMPLEX*16 array, dimension (N)
The eigenvalues of A.
WORK
WORK is COMPLEX*16 array, dimension (N*N)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESULT
RESULT is DOUBLE PRECISION array, dimension (2)
RESULT(1) = | A E - E W | / ( |A| |E| ulp )
RESULT(2) = max | m-norm(E(j)) - 1 | / ( n ulp )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zget23 (logical COMP, integer ISRT, character BALANC, integer JTYPE, double
precision THRESH, integer, dimension( 4 ) ISEED, integer NOUNIT, integer N, complex*16,
dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) H, complex*16,
dimension( * ) W, complex*16, dimension( * ) W1, complex*16, dimension( ldvl, * ) VL,
integer LDVL, complex*16, dimension( ldvr, * ) VR, integer LDVR, complex*16, 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, complex*16, dimension( *
) WORK, integer LWORK, double precision, dimension( * ) RWORK, integer INFO)
ZGET23
Purpose:
ZGET23 checks the nonsymmetric eigenvalue problem driver CGEEVX.
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 diagonal matrix with diagonal entries W(j).
(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 i-th column of VR.
(4) | |VL(i)| - 1 | / ulp and largest component real
VL(i) denotes the i-th 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 ZGEEVX 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 ZGEEVX 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
ISRT
ISRT is INTEGER
If COMP = .TRUE., ISRT indicates in how the eigenvalues
corresponding to values in RCDVIN and RCDEIN are ordered:
= 0 means the eigenvalues are sorted by
increasing real part
= 1 means the eigenvalues are sorted by
increasing imaginary part
If COMP = .FALSE., ISRT is not referenced.
BALANC
BALANC 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
JTYPE
JTYPE is INTEGER
Type of input matrix. Used to label output if error occurs.
THRESH
THRESH 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.
ISEED
ISEED 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.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns INFO not equal to 0.)
N
N is INTEGER
The dimension of A. N must be at least 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
Used to hold the matrix whose eigenvalues are to be
computed.
LDA
LDA is INTEGER
The leading dimension of A, and H. LDA must be at
least 1 and at least N.
H
H is COMPLEX*16 array, dimension (LDA,N)
Another copy of the test matrix A, modified by ZGEEVX.
W
W is COMPLEX*16 array, dimension (N)
Contains the eigenvalues of A.
W1
W1 is COMPLEX*16 array, dimension (N)
Like W, this array contains the eigenvalues of A,
but those computed when ZGEEVX only computes a partial
eigendecomposition, i.e. not the eigenvalues and left
and right eigenvectors.
VL
VL is COMPLEX*16 array, dimension (LDVL,N)
VL holds the computed left eigenvectors.
LDVL
LDVL is INTEGER
Leading dimension of VL. Must be at least max(1,N).
VR
VR is COMPLEX*16 array, dimension (LDVR,N)
VR holds the computed right eigenvectors.
LDVR
LDVR is INTEGER
Leading dimension of VR. Must be at least max(1,N).
LRE
LRE is COMPLEX*16 array, dimension (LDLRE,N)
LRE holds the computed right or left eigenvectors.
LDLRE
LDLRE is INTEGER
Leading dimension of LRE. Must be at least max(1,N).
RCONDV
RCONDV is DOUBLE PRECISION array, dimension (N)
RCONDV holds the computed reciprocal condition numbers
for eigenvectors.
RCNDV1
RCNDV1 is DOUBLE PRECISION array, dimension (N)
RCNDV1 holds more computed reciprocal condition numbers
for eigenvectors.
RCDVIN
RCDVIN is DOUBLE PRECISION array, dimension (N)
When COMP = .TRUE. RCDVIN holds the precomputed reciprocal
condition numbers for eigenvectors to be compared with
RCONDV.
RCONDE
RCONDE is DOUBLE PRECISION array, dimension (N)
RCONDE holds the computed reciprocal condition numbers
for eigenvalues.
RCNDE1
RCNDE1 is DOUBLE PRECISION array, dimension (N)
RCNDE1 holds more computed reciprocal condition numbers
for eigenvalues.
RCDEIN
RCDEIN is DOUBLE PRECISION array, dimension (N)
When COMP = .TRUE. RCDEIN holds the precomputed reciprocal
condition numbers for eigenvalues to be compared with
RCONDE.
SCALE
SCALE is DOUBLE PRECISION array, dimension (N)
Holds information describing balancing of matrix.
SCALE1
SCALE1 is DOUBLE PRECISION array, dimension (N)
Holds information describing balancing of matrix.
RESULT
RESULT 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.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The number of entries in WORK. This must be at least
2*N, and 2*N+N**2 if tests 9, 10 or 11 are to be performed.
RWORK
RWORK is DOUBLE PRECISION array, dimension (2*N)
INFO
INFO is INTEGER
If 0, successful exit.
If <0, input parameter -INFO had an incorrect value.
If >0, ZGEEVX 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 zget24 (logical COMP, integer JTYPE, double precision THRESH, integer, dimension( 4
) ISEED, integer NOUNIT, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( lda, * ) H, complex*16, dimension( lda, * ) HT, complex*16,
dimension( * ) W, complex*16, dimension( * ) WT, complex*16, dimension( * ) WTMP,
complex*16, dimension( ldvs, * ) VS, integer LDVS, complex*16, dimension( ldvs, * ) VS1,
double precision RCDEIN, double precision RCDVIN, integer NSLCT, integer, dimension( * )
ISLCT, integer ISRT, double precision, dimension( 17 ) RESULT, complex*16, dimension( * )
WORK, integer LWORK, double precision, dimension( * ) RWORK, logical, dimension( * )
BWORK, integer INFO)
ZGET24
Purpose:
ZGET24 checks the nonsymmetric eigenvalue (Schur form) problem
expert driver ZGEESX.
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 W 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 W are eigenvalues of T
1/ulp otherwise
If workspace sufficient, also compare W 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 ZGEESX 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 ZGEESX 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
JTYPE
JTYPE is INTEGER
Type of input matrix. Used to label output if error occurs.
ISEED
ISEED 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.
THRESH
THRESH 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.
NOUNIT
NOUNIT is INTEGER
The FORTRAN unit number for printing out error messages
(e.g., if a routine returns INFO not equal to 0.)
N
N is INTEGER
The dimension of A. N must be at least 0.
A
A is COMPLEX*16 array, dimension (LDA, N)
Used to hold the matrix whose eigenvalues are to be
computed.
LDA
LDA is INTEGER
The leading dimension of A, and H. LDA must be at
least 1 and at least N.
H
H is COMPLEX*16 array, dimension (LDA, N)
Another copy of the test matrix A, modified by ZGEESX.
HT
HT is COMPLEX*16 array, dimension (LDA, N)
Yet another copy of the test matrix A, modified by ZGEESX.
W
W is COMPLEX*16 array, dimension (N)
The computed eigenvalues of A.
WT
WT is COMPLEX*16 array, dimension (N)
Like W, this array contains the eigenvalues of A,
but those computed when ZGEESX only computes a partial
eigendecomposition, i.e. not Schur vectors
WTMP
WTMP is COMPLEX*16 array, dimension (N)
Like W, this array contains the eigenvalues of A,
but sorted by increasing real or imaginary part.
VS
VS is COMPLEX*16 array, dimension (LDVS, N)
VS holds the computed Schur vectors.
LDVS
LDVS is INTEGER
Leading dimension of VS. Must be at least max(1, N).
VS1
VS1 is COMPLEX*16 array, dimension (LDVS, N)
VS1 holds another copy of the computed Schur vectors.
RCDEIN
RCDEIN is DOUBLE PRECISION
When COMP = .TRUE. RCDEIN holds the precomputed reciprocal
condition number for the average of selected eigenvalues.
RCDVIN
RCDVIN is DOUBLE PRECISION
When COMP = .TRUE. RCDVIN holds the precomputed reciprocal
condition number for the selected right invariant subspace.
NSLCT
NSLCT is INTEGER
When COMP = .TRUE. the number of selected eigenvalues
corresponding to the precomputed values RCDEIN and RCDVIN.
ISLCT
ISLCT 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 J-th largest real or imaginary part is
selected. The real part is used if ISRT = 0, and the
imaginary part if ISRT = 1.
Not referenced if COMP = .FALSE.
ISRT
ISRT is INTEGER
When COMP = .TRUE., ISRT describes how ISLCT is used to
choose a subset of the spectrum.
Not referenced if COMP = .FALSE.
RESULT
RESULT 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.
WORK
WORK is COMPLEX*16 array, dimension (2*N*N)
LWORK
LWORK is INTEGER
The number of entries in WORK to be passed to ZGEESX. This
must be at least 2*N, and N*(N+1)/2 if tests 14--16 are to
be performed.
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
BWORK
BWORK is LOGICAL array, dimension (N)
INFO
INFO is INTEGER
If 0, successful exit.
If <0, input parameter -INFO had an incorrect value.
If >0, ZGEESX 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 zget35 (double precision RMAX, integer LMAX, integer NINFO, integer KNT, integer
NIN)
ZGET35
Purpose:
ZGET35 tests ZTRSYL, 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.
LMAX
LMAX is INTEGER
Example number where largest test ratio achieved.
NINFO
NINFO is INTEGER
Number of examples where INFO is nonzero.
KNT
KNT is INTEGER
Total number of examples tested.
NIN
NIN is INTEGER
Input logical unit number.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zget36 (double precision RMAX, integer LMAX, integer NINFO, integer KNT, integer
NIN)
ZGET36
Purpose:
ZGET36 tests ZTREXC, a routine for reordering diagonal entries of a
matrix in complex Schur form. Thus, ZLAEXC computes a unitary 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*Q-T2 is small, that T2
is in Schur form, and that the final position of the IFST block is
ILST.
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.
LMAX
LMAX is INTEGER
Example number where largest test ratio achieved.
NINFO
NINFO is INTEGER
Number of examples where INFO is nonzero.
KNT
KNT is INTEGER
Total number of examples tested.
NIN
NIN is INTEGER
Input logical unit number.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zget37 (double precision, dimension( 3 ) RMAX, integer, dimension( 3 ) LMAX,
integer, dimension( 3 ) NINFO, integer KNT, integer NIN)
ZGET37
Purpose:
ZGET37 tests ZTRSNA, 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 ZTRSNA
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))
LMAX
LMAX is INTEGER array, dimension (3)
LMAX(i) is example number where largest test ratio
RMAX(i) is achieved. Also:
If ZGEHRD returns INFO nonzero on example i, LMAX(1)=i
If ZHSEQR returns INFO nonzero on example i, LMAX(2)=i
If ZTRSNA returns INFO nonzero on example i, LMAX(3)=i
NINFO
NINFO is INTEGER array, dimension (3)
NINFO(1) = No. of times ZGEHRD returned INFO nonzero
NINFO(2) = No. of times ZHSEQR returned INFO nonzero
NINFO(3) = No. of times ZTRSNA returned INFO nonzero
KNT
KNT is INTEGER
Total number of examples tested.
NIN
NIN is INTEGER
Input logical unit number
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zget38 (double precision, dimension( 3 ) RMAX, integer, dimension( 3 ) LMAX,
integer, dimension( 3 ) NINFO, integer KNT, integer NIN)
ZGET38
Purpose:
ZGET38 tests ZTRSEN, 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 ZHST01 or comparing
different calls to ZTRSEN
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))
LMAX
LMAX is INTEGER array, dimension (3)
LMAX(i) is example number where largest test ratio
RMAX(i) is achieved. Also:
If ZGEHRD returns INFO nonzero on example i, LMAX(1)=i
If ZHSEQR returns INFO nonzero on example i, LMAX(2)=i
If ZTRSEN returns INFO nonzero on example i, LMAX(3)=i
NINFO
NINFO is INTEGER array, dimension (3)
NINFO(1) = No. of times ZGEHRD returned INFO nonzero
NINFO(2) = No. of times ZHSEQR returned INFO nonzero
NINFO(3) = No. of times ZTRSEN returned INFO nonzero
KNT
KNT is INTEGER
Total number of examples tested.
NIN
NIN is INTEGER
Input logical unit number.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zget51 (integer ITYPE, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldu, * ) U, integer
LDU, complex*16, dimension( ldv, * ) V, integer LDV, complex*16, dimension( * ) WORK,
double precision, dimension( * ) RWORK, double precision RESULT)
ZGET51
Purpose:
ZGET51 generally checks a decomposition of the form
A = U B VC>
where * means conjugate transpose and U and V are unitary.
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 )
N
N is INTEGER
The size of the matrix. If it is zero, ZGET51 does nothing.
It must be at least zero.
A
A is COMPLEX*16 array, dimension (LDA, N)
The original (unfactored) matrix.
LDA
LDA is INTEGER
The leading dimension of A. It must be at least 1
and at least N.
B
B is COMPLEX*16 array, dimension (LDB, N)
The factored matrix.
LDB
LDB is INTEGER
The leading dimension of B. It must be at least 1
and at least N.
U
U is COMPLEX*16 array, dimension (LDU, N)
The unitary matrix on the left-hand side in the
decomposition.
Not referenced if ITYPE=2
LDU
LDU is INTEGER
The leading dimension of U. LDU must be at least N and
at least 1.
V
V is COMPLEX*16 array, dimension (LDV, N)
The unitary matrix on the left-hand side in the
decomposition.
Not referenced if ITYPE=2
LDV
LDV is INTEGER
The leading dimension of V. LDV must be at least N and
at least 1.
WORK
WORK is COMPLEX*16 array, dimension (2*N**2)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESULT
RESULT 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 zget52 (logical LEFT, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( lde, * ) E, integer
LDE, complex*16, dimension( * ) ALPHA, complex*16, dimension( * ) BETA, complex*16,
dimension( * ) WORK, double precision, dimension( * ) RWORK, double precision, dimension(
2 ) RESULT)
ZGET52
Purpose:
ZGET52 does an eigenvector check for the generalized eigenvalue
problem.
The basic test for right eigenvectors is:
| b(i) A E(i) - a(i) B E(i) |
RESULT(1) = max -------------------------------
i n ulp max( |b(i) A|, |a(i) B| )
using the 1-norm. Here, a(i)/b(i) = w is the i-th generalized
eigenvalue of A - w B, or, equivalently, b(i)/a(i) = m is the i-th
generalized eigenvalue of m A - B.
H H _ _
For left eigenvectors, A , B , a, and b are used.
ZGET52 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(i)=b(i)=0, then the eigenvector is set to be the jth coordinate
vector. The normalization test is:
RESULT(2) = max | M(v(i)) - 1 | / ( n ulp )
eigenvectors v(i)
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.
N
N is INTEGER
The size of the matrices. If it is zero, ZGET52 does
nothing. It must be at least zero.
A
A is COMPLEX*16 array, dimension (LDA, N)
The matrix A.
LDA
LDA is INTEGER
The leading dimension of A. It must be at least 1
and at least N.
B
B is COMPLEX*16 array, dimension (LDB, N)
The matrix B.
LDB
LDB is INTEGER
The leading dimension of B. It must be at least 1
and at least N.
E
E is COMPLEX*16 array, dimension (LDE, N)
The matrix of eigenvectors. It must be O( 1 ).
LDE
LDE is INTEGER
The leading dimension of E. It must be at least 1 and at
least N.
ALPHA
ALPHA is COMPLEX*16 array, dimension (N)
The values a(i) as described above, which, along with b(i),
define the generalized eigenvalues.
BETA
BETA is COMPLEX*16 array, dimension (N)
The values b(i) as described above, which, along with a(i),
define the generalized eigenvalues.
WORK
WORK is COMPLEX*16 array, dimension (N**2)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESULT
RESULT 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 zget54 (integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16,
dimension( ldb, * ) B, integer LDB, complex*16, dimension( lds, * ) S, integer LDS,
complex*16, dimension( ldt, * ) T, integer LDT, complex*16, dimension( ldu, * ) U, integer
LDU, complex*16, dimension( ldv, * ) V, integer LDV, complex*16, dimension( * ) WORK,
double precision RESULT)
ZGET54
Purpose:
ZGET54 checks a generalized decomposition of the form
A = U*S*V' and B = U*T* V'
where ' means conjugate transpose and U and V are unitary.
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.
A
A is COMPLEX*16 array, dimension (LDA, N)
The original (unfactored) matrix A.
LDA
LDA is INTEGER
The leading dimension of A. It must be at least 1
and at least N.
B
B is COMPLEX*16 array, dimension (LDB, N)
The original (unfactored) matrix B.
LDB
LDB is INTEGER
The leading dimension of B. It must be at least 1
and at least N.
S
S is COMPLEX*16 array, dimension (LDS, N)
The factored matrix S.
LDS
LDS is INTEGER
The leading dimension of S. It must be at least 1
and at least N.
T
T is COMPLEX*16 array, dimension (LDT, N)
The factored matrix T.
LDT
LDT is INTEGER
The leading dimension of T. It must be at least 1
and at least N.
U
U is COMPLEX*16 array, dimension (LDU, N)
The orthogonal matrix on the left-hand side in the
decomposition.
LDU
LDU is INTEGER
The leading dimension of U. LDU must be at least N and
at least 1.
V
V is COMPLEX*16 array, dimension (LDV, N)
The orthogonal matrix on the left-hand side in the
decomposition.
LDV
LDV is INTEGER
The leading dimension of V. LDV must be at least N and
at least 1.
WORK
WORK is COMPLEX*16 array, dimension (3*N**2)
RESULT
RESULT 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 zglmts (integer N, integer M, integer P, complex*16, dimension( lda, * ) A,
complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( ldb, * ) B,
complex*16, dimension( ldb, * ) BF, integer LDB, complex*16, dimension( * ) D, complex*16,
dimension( * ) DF, complex*16, dimension( * ) X, complex*16, dimension( * ) U, complex*16,
dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double
precision RESULT)
ZGLMTS
Purpose:
ZGLMTS tests ZGGGLM - 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.
M
M is INTEGER
The number of columns of the matrix A. M >= 0.
P
P is INTEGER
The number of columns of the matrix B. P >= 0.
A
A is COMPLEX*16 array, dimension (LDA,M)
The N-by-M matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,M)
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF. LDA >= max(M,N).
B
B is COMPLEX*16 array, dimension (LDB,P)
The N-by-P matrix A.
BF
BF is COMPLEX*16 array, dimension (LDB,P)
LDB
LDB is INTEGER
The leading dimension of the arrays B, BF. LDB >= max(P,N).
D
D is COMPLEX*16 array, dimension( N )
On input, the left hand side of the GLM.
DF
DF is COMPLEX*16 array, dimension( N )
X
X is COMPLEX*16 array, dimension( M )
solution vector X in the GLM problem.
U
U is COMPLEX*16 array, dimension( P )
solution vector U in the GLM problem.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT 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 zgqrts (integer N, integer M, integer P, complex*16, dimension( lda, * ) A,
complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAUA, complex*16,
dimension( ldb, * ) B, complex*16, dimension( ldb, * ) BF, complex*16, dimension( ldb, * )
Z, complex*16, dimension( ldb, * ) T, complex*16, dimension( ldb, * ) BWK, integer LDB,
complex*16, dimension( * ) TAUB, complex*16, dimension( lwork ) WORK, integer LWORK,
double precision, dimension( * ) RWORK, double precision, dimension( 4 ) RESULT)
ZGQRTS
Purpose:
ZGQRTS tests ZGGQRF, which computes the GQR factorization of an
N-by-M matrix A and a N-by-P 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.
M
M is INTEGER
The number of columns of the matrix A. M >= 0.
P
P is INTEGER
The number of columns of the matrix B. P >= 0.
A
A is COMPLEX*16 array, dimension (LDA,M)
The N-by-M matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the GQR factorization of A and B, as returned
by ZGGQRF, see CGGQRF for further details.
Q
Q is COMPLEX*16 array, dimension (LDA,N)
The M-by-M unitary matrix Q.
R
R is COMPLEX*16 array, dimension (LDA,MAX(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, R and Q.
LDA >= max(M,N).
TAUA
TAUA is COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by ZGGQRF.
B
B is COMPLEX*16 array, dimension (LDB,P)
On entry, the N-by-P matrix A.
BF
BF is COMPLEX*16 array, dimension (LDB,N)
Details of the GQR factorization of A and B, as returned
by ZGGQRF, see CGGQRF for further details.
Z
Z is COMPLEX*16 array, dimension (LDB,P)
The P-by-P unitary matrix Z.
T
T is COMPLEX*16 array, dimension (LDB,max(P,N))
BWK
BWK is COMPLEX*16 array, dimension (LDB,N)
LDB
LDB is INTEGER
The leading dimension of the arrays B, BF, Z and T.
LDB >= max(P,N).
TAUB
TAUB is COMPLEX*16 array, dimension (min(P,N))
The scalar factors of the elementary reflectors, as returned
by DGGRQF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK, LWORK >= max(N,M,P)**2.
RWORK
RWORK is DOUBLE PRECISION array, dimension (max(N,M,P))
RESULT
RESULT 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 zgrqts (integer M, integer P, integer N, complex*16, dimension( lda, * ) A,
complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAUA, complex*16,
dimension( ldb, * ) B, complex*16, dimension( ldb, * ) BF, complex*16, dimension( ldb, * )
Z, complex*16, dimension( ldb, * ) T, complex*16, dimension( ldb, * ) BWK, integer LDB,
complex*16, dimension( * ) TAUB, complex*16, dimension( lwork ) WORK, integer LWORK,
double precision, dimension( * ) RWORK, double precision, dimension( 4 ) RESULT)
ZGRQTS
Purpose:
ZGRQTS tests ZGGRQF, which computes the GRQ factorization of an
M-by-N matrix A and a P-by-N 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.
P
P is INTEGER
The number of rows of the matrix B. P >= 0.
N
N is INTEGER
The number of columns of the matrices A and B. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The M-by-N matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the GRQ factorization of A and B, as returned
by ZGGRQF, see CGGRQF for further details.
Q
Q is COMPLEX*16 array, dimension (LDA,N)
The N-by-N unitary matrix Q.
R
R is COMPLEX*16 array, dimension (LDA,MAX(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, R and Q.
LDA >= max(M,N).
TAUA
TAUA is COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by DGGQRC.
B
B is COMPLEX*16 array, dimension (LDB,N)
On entry, the P-by-N matrix A.
BF
BF is COMPLEX*16 array, dimension (LDB,N)
Details of the GQR factorization of A and B, as returned
by ZGGRQF, see CGGRQF for further details.
Z
Z is DOUBLE PRECISION array, dimension (LDB,P)
The P-by-P unitary matrix Z.
T
T is COMPLEX*16 array, dimension (LDB,max(P,N))
BWK
BWK is COMPLEX*16 array, dimension (LDB,N)
LDB
LDB is INTEGER
The leading dimension of the arrays B, BF, Z and T.
LDB >= max(P,N).
TAUB
TAUB is COMPLEX*16 array, dimension (min(P,N))
The scalar factors of the elementary reflectors, as returned
by DGGRQF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK, LWORK >= max(M,P,N)**2.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT 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 zgsvts3 (integer M, integer P, integer N, complex*16, dimension( lda, * ) A,
complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( ldb, * ) B,
complex*16, dimension( ldb, * ) BF, integer LDB, complex*16, dimension( ldu, * ) U,
integer LDU, complex*16, dimension( ldv, * ) V, integer LDV, complex*16, dimension( ldq, *
) Q, integer LDQ, double precision, dimension( * ) ALPHA, double precision, dimension( * )
BETA, complex*16, dimension( ldr, * ) R, integer LDR, integer, dimension( * ) IWORK,
complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * )
RWORK, double precision, dimension( 6 ) RESULT)
ZGSVTS3
Purpose:
ZGSVTS3 tests ZGGSVD3, which computes the GSVD of an M-by-N matrix A
and a P-by-N 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.
P
P is INTEGER
The number of rows of the matrix B. P >= 0.
N
N is INTEGER
The number of columns of the matrices A and B. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,M)
The M-by-N matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the GSVD of A and B, as returned by ZGGSVD3,
see ZGGSVD3 for further details.
LDA
LDA is INTEGER
The leading dimension of the arrays A and AF.
LDA >= max( 1,M ).
B
B is COMPLEX*16 array, dimension (LDB,P)
On entry, the P-by-N matrix B.
BF
BF is COMPLEX*16 array, dimension (LDB,N)
Details of the GSVD of A and B, as returned by ZGGSVD3,
see ZGGSVD3 for further details.
LDB
LDB is INTEGER
The leading dimension of the arrays B and BF.
LDB >= max(1,P).
U
U is COMPLEX*16 array, dimension(LDU,M)
The M by M unitary matrix U.
LDU
LDU is INTEGER
The leading dimension of the array U. LDU >= max(1,M).
V
V is COMPLEX*16 array, dimension(LDV,M)
The P by P unitary matrix V.
LDV
LDV is INTEGER
The leading dimension of the array V. LDV >= max(1,P).
Q
Q is COMPLEX*16 array, dimension(LDQ,N)
The N by N unitary matrix Q.
LDQ
LDQ is INTEGER
The leading dimension of the array Q. LDQ >= max(1,N).
ALPHA
ALPHA is DOUBLE PRECISION array, dimension (N)
BETA
BETA 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 ZGGSVD3 for details.
R
R is COMPLEX*16 array, dimension(LDQ,N)
The upper triangular matrix R.
LDR
LDR is INTEGER
The leading dimension of the array R. LDR >= max(1,N).
IWORK
IWORK is INTEGER array, dimension (N)
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK,
LWORK >= max(M,P,N)*max(M,P,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (max(M,P,N))
RESULT
RESULT 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 zhbt21 (character UPLO, integer N, integer KA, integer KS, complex*16, dimension(
lda, * ) A, integer LDA, double precision, dimension( * ) D, double precision, dimension(
* ) E, complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension( * ) WORK,
double precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
ZHBT21
Purpose:
ZHBT21 generally checks a decomposition of the form
A = U S UC>
where * means conjugate transpose, A is hermitian banded, U is
unitary, 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.
N
N is INTEGER
The size of the matrix. If it is zero, ZHBT21 does nothing.
It must be at least zero.
KA
KA is INTEGER
The bandwidth of the matrix A. It must be at least zero. If
it is larger than N-1, then max( 0, N-1 ) will be used.
KS
KS 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 tri-diagonal.
A
A is COMPLEX*16 array, dimension (LDA, N)
The original (unfactored) matrix. It is assumed to be
hermitian, and only the upper (UPLO='U') or only the lower
(UPLO='L') will be referenced.
LDA
LDA is INTEGER
The leading dimension of A. It must be at least 1
and at least min( KA, N-1 ).
D
D is DOUBLE PRECISION array, dimension (N)
The diagonal of the (symmetric tri-) diagonal matrix S.
E
E is DOUBLE PRECISION array, dimension (N-1)
The off-diagonal 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.
U
U is COMPLEX*16 array, dimension (LDU, N)
The unitary matrix in the decomposition, expressed as a
dense matrix (i.e., not as a product of Householder
transformations, Givens transformations, etc.)
LDU
LDU is INTEGER
The leading dimension of U. LDU must be at least N and
at least 1.
WORK
WORK is COMPLEX*16 array, dimension (N**2)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESULT
RESULT 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 zhet21 (integer ITYPE, character UPLO, integer N, integer KBAND, complex*16,
dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D, double precision,
dimension( * ) E, complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension(
ldv, * ) V, integer LDV, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK,
double precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
ZHET21
Purpose:
ZHET21 generally checks a decomposition of the form
A = U S UC>
where * means conjugate transpose, A is hermitian, U is unitary, and
S is diagonal (if KBAND=0) or (real) 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 - UV* | / ( n ulp )
For ITYPE > 1, the transformation U is expressed as a product
V = H(1)...H(n-2), where H(j) = I - tau(j) v(j) v(j)C> and each
vector v(j) has its first j elements 0 and the remaining n-j 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 unitary 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 unitary matrix and
as a product of Housholder transformations:
RESULT(1) = | I - UV* | / ( n ulp )
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.
N
N is INTEGER
The size of the matrix. If it is zero, ZHET21 does nothing.
It must be at least zero.
KBAND
KBAND 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 tri-diagonal.
A
A is COMPLEX*16 array, dimension (LDA, N)
The original (unfactored) matrix. It is assumed to be
hermitian, and only the upper (UPLO='U') or only the lower
(UPLO='L') will be referenced.
LDA
LDA is INTEGER
The leading dimension of A. It must be at least 1
and at least N.
D
D is DOUBLE PRECISION array, dimension (N)
The diagonal of the (symmetric tri-) diagonal matrix.
E
E is DOUBLE PRECISION array, dimension (N-1)
The off-diagonal 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.
U
U is COMPLEX*16 array, dimension (LDU, N)
If ITYPE=1 or 3, this contains the unitary matrix in
the decomposition, expressed as a dense matrix. If ITYPE=2,
then it is not referenced.
LDU
LDU is INTEGER
The leading dimension of U. LDU must be at least N and
at least 1.
V
V is COMPLEX*16 array, dimension (LDV, N)
If ITYPE=2 or 3, the columns of this array contain the
Householder vectors used to describe the unitary 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.
LDV
LDV is INTEGER
The leading dimension of V. LDV must be at least N and
at least 1.
TAU
TAU is COMPLEX*16 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(n-2)
If ITYPE < 2, then TAU is not referenced.
WORK
WORK is COMPLEX*16 array, dimension (2*N**2)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESULT
RESULT 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 zhet22 (integer ITYPE, character UPLO, integer N, integer M, integer KBAND,
complex*16, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D, double
precision, dimension( * ) E, complex*16, dimension( ldu, * ) U, integer LDU, complex*16,
dimension( ldv, * ) V, integer LDV, complex*16, dimension( * ) TAU, complex*16, dimension(
* ) WORK, double precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
ZHET22
Purpose:
ZHET22 generally checks a decomposition of the form
A U = U S
where A is complex Hermitian, 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, ZHET22 does nothing.
It must be at least zero.
Not modified.
M INTEGER
The number of columns of U. If it is zero, ZHET22 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 tri-diagonal.
Not modified.
A COMPLEX*16 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 off-diagonal 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 COMPLEX*16 array, dimension (LDU, N)
If ITYPE=1, this contains the orthogonal matrix in
the decomposition, expressed as a dense matrix.
Not modified.
LDU INTEGER
The leading dimension of U. LDU must be at least N and
at least 1.
Not modified.
V COMPLEX*16 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 COMPLEX*16 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(n-2)
If ITYPE < 2, then TAU is not referenced.
Not modified.
WORK COMPLEX*16 array, dimension (2*N**2)
Workspace.
Modified.
RWORK DOUBLE PRECISION array, dimension (N)
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 zhpt21 (integer ITYPE, character UPLO, integer N, integer KBAND, complex*16,
dimension( * ) AP, double precision, dimension( * ) D, double precision, dimension( * ) E,
complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension( * ) VP, complex*16,
dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision, dimension( * )
RWORK, double precision, dimension( 2 ) RESULT)
ZHPT21
Purpose:
ZHPT21 generally checks a decomposition of the form
A = U S UC>
where * means conjugate transpose, A is hermitian, U is
unitary, and S is diagonal (if KBAND=0) or (real) 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 - UV* | / ( 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*(j-1)/2 ) if UPLO='U'
AP( i + (2*n-j)*(j-1)/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(n-1)...H(1), where
H(j) = I - tau(j) v(j) v(j)C>
and the first j-1 elements of v(j) are stored in V(1:j-1,j+1),
(i.e., VP( j*(j+1)/2 + 1 : j*(j+1)/2 + j-1 ) ),
the j-th element is 1, and the last n-j elements are 0.
If UPLO='L', then V = H(1)...H(n-1), where
H(j) = I - tau(j) v(j) v(j)C>
and the first j elements of v(j) are 0, the (j+1)-st is 1, and the
(j+2)-nd through n-th elements are stored in V(j+2:n,j) (i.e.,
in VP( (2*n-j)*(j-1)/2 + j+2 : (2*n-j)*(j-1)/2 + n ) .)
Parameters:
ITYPE
ITYPE is INTEGER
Specifies the type of tests to be performed.
1: U expressed as a dense unitary 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 unitary matrix and
as a product of Housholder transformations:
RESULT(1) = | I - UV* | / ( n ulp )
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.
N
N is INTEGER
The size of the matrix. If it is zero, ZHPT21 does nothing.
It must be at least zero.
KBAND
KBAND 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 tri-diagonal.
AP
AP is COMPLEX*16 array, dimension (N*(N+1)/2)
The original (unfactored) matrix. It is assumed to be
hermitian, and contains the columns of just the upper
triangle (UPLO='U') or only the lower triangle (UPLO='L'),
packed one after another.
D
D is DOUBLE PRECISION array, dimension (N)
The diagonal of the (symmetric tri-) diagonal matrix.
E
E is DOUBLE PRECISION array, dimension (N)
The off-diagonal 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.
U
U is COMPLEX*16 array, dimension (LDU, N)
If ITYPE=1 or 3, this contains the unitary matrix in
the decomposition, expressed as a dense matrix. If ITYPE=2,
then it is not referenced.
LDU
LDU is INTEGER
The leading dimension of U. LDU must be at least N and
at least 1.
VP
VP 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 unitary 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.
TAU
TAU is COMPLEX*16 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(n-2)
If ITYPE < 2, then TAU is not referenced.
WORK
WORK is COMPLEX*16 array, dimension (N**2)
Workspace.
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
Workspace.
RESULT
RESULT 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 zhst01 (integer N, integer ILO, integer IHI, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( ldh, * ) H, integer LDH, complex*16, dimension( ldq, *
) Q, integer LDQ, complex*16, dimension( lwork ) WORK, integer LWORK, double precision,
dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
ZHST01
Purpose:
ZHST01 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 ZGEHRD + ZUNGHR.
In this version, ILO and IHI are not used, but they could be used
to save some work if this is desired.
Parameters:
N
N is INTEGER
The order of the matrix A. N >= 0.
ILO
ILO is INTEGER
IHI
IHI is INTEGER
A is assumed to be upper triangular in rows and columns
1:ILO-1 and IHI+1:N, so Q differs from the identity only in
rows and columns ILO+1:IHI.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original n by n matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
H
H is COMPLEX*16 array, dimension (LDH,N)
The upper Hessenberg matrix H from the reduction A = Q*H*Q'
as computed by ZGEHRD. H is assumed to be zero below the
first subdiagonal.
LDH
LDH is INTEGER
The leading dimension of the array H. LDH >= max(1,N).
Q
Q is COMPLEX*16 array, dimension (LDQ,N)
The orthogonal matrix Q from the reduction A = Q*H*Q' as
computed by ZGEHRD + ZUNGHR.
LDQ
LDQ is INTEGER
The leading dimension of the array Q. LDQ >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK >= 2*N*N.
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESULT
RESULT 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 zlarfy (character UPLO, integer N, complex*16, dimension( * ) V, integer INCV,
complex*16 TAU, complex*16, dimension( ldc, * ) C, integer LDC, complex*16, dimension( * )
WORK)
ZLARFY
Purpose:
ZLARFY applies an elementary reflector, or Householder matrix, H,
to an n x n Hermitian 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
Hermitian matrix C is stored.
= 'U': Upper triangle
= 'L': Lower triangle
N
N is INTEGER
The number of rows and columns of the matrix C. N >= 0.
V
V is COMPLEX*16 array, dimension
(1 + (N-1)*abs(INCV))
The vector v as described above.
INCV
INCV is INTEGER
The increment between successive elements of v. INCV must
not be zero.
TAU
TAU is COMPLEX*16
The value tau as described above.
C
C is COMPLEX*16 array, dimension (LDC, N)
On entry, the matrix C.
On exit, C is overwritten by H * C * H'.
LDC
LDC is INTEGER
The leading dimension of the array C. LDC >= max( 1, N ).
WORK
WORK is COMPLEX*16 array, dimension (N)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlarhs (character*3 PATH, character XTYPE, character UPLO, character TRANS, integer
M, integer N, integer KL, integer KU, integer NRHS, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, *
) B, integer LDB, integer, dimension( 4 ) ISEED, integer INFO)
ZLARHS
Purpose:
ZLARHS 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, A**T (transpose of A), or A**H (conjugate
transpose of A).
Parameters:
PATH
PATH is CHARACTER*3
The type of the complex matrix A. PATH may be given in any
combination of upper and lower case. Valid paths include
xGE: General m x n matrix
xGB: General banded matrix
xPO: Hermitian positive definite, 2-D storage
xPP: Hermitian positive definite packed
xPB: Hermitian positive definite banded
xHE: Hermitian indefinite, 2-D storage
xHP: Hermitian indefinite packed
xHB: Hermitian indefinite banded
xSY: Symmetric indefinite, 2-D storage
xSP: Symmetric indefinite packed
xSB: Symmetric indefinite banded
xTR: Triangular
xTP: Triangular packed
xTB: Triangular banded
xQR: General m x n matrix
xLQ: General m x n matrix
xQL: General m x n matrix
xRQ: General m x n matrix
where the leading character indicates the precision.
XTYPE
XTYPE is CHARACTER*1
Specifies how the exact solution X will be determined:
= 'N': New solution; generate a random X.
= 'C': Computed; use value of X on entry.
UPLO
UPLO is CHARACTER*1
Used only if A is symmetric or triangular; specifies whether
the upper or lower triangular part of the matrix A is stored.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Used only if A is nonsymmetric; specifies the operation
applied to the matrix A.
= 'N': B := A * X
= 'T': B := A**T * X
= 'C': B := A**H * X
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
KL
KL is INTEGER
Used only if A is a band matrix; specifies the number of
subdiagonals of A if A is a general band matrix or if A is
symmetric or triangular and UPLO = 'L'; specifies the number
of superdiagonals of A if A is symmetric or triangular and
UPLO = 'U'. 0 <= KL <= M-1.
KU
KU is INTEGER
Used only if A is a general band matrix or if A is
triangular.
If PATH = xGB, specifies the number of superdiagonals of A,
and 0 <= KU <= N-1.
If PATH = xTR, xTP, or xTB, specifies whether or not the
matrix has unit diagonal:
= 1: matrix has non-unit diagonal (default)
= 2: matrix has unit diagonal
NRHS
NRHS is INTEGER
The number of right hand side vectors in the system A*X = B.
A
A is COMPLEX*16 array, dimension (LDA,N)
The test matrix whose type is given by PATH.
LDA
LDA is INTEGER
The leading dimension of the array A.
If PATH = xGB, LDA >= KL+KU+1.
If PATH = xPB, xSB, xHB, or xTB, LDA >= KL+1.
Otherwise, LDA >= max(1,M).
X
X is or output) COMPLEX*16 array, dimension (LDX,NRHS)
On entry, if XTYPE = 'C' (for 'Computed'), then X contains
the exact solution to the system of linear equations.
On exit, if XTYPE = 'N' (for 'New'), then X is initialized
with random values.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T', LDX >= max(1,M).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vector(s) for the system of equations,
computed from B = op(A) * X, where op(A) is determined by
TRANS.
LDB
LDB is INTEGER
The leading dimension of the array B. If TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T', LDB >= max(1,N).
ISEED
ISEED is INTEGER array, dimension (4)
The seed vector for the random number generator (used in
ZLATMS). Modified on exit.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlatm4 (integer ITYPE, integer N, integer NZ1, integer NZ2, logical RSIGN, double
precision AMAGN, double precision RCOND, double precision TRIANG, integer IDIST, integer,
dimension( 4 ) ISEED, complex*16, dimension( lda, * ) A, integer LDA)
ZLATM4
Purpose:
ZLATM4 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, RSIGN, AMAGN, and RCOND.
It then fills in the upper triangle with random numbers, if TRIANG is
non-zero.
Parameters:
ITYPE
ITYPE is INTEGER
The "type" of matrix on the diagonal and sub-diagonal.
If ITYPE < 0, then type abs(ITYPE) is generated and then
swapped end for end (A(I,J) := A'(N-J,N-I).) See also
the description of AMAGN and RSIGN.
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=(N-1)/2.
If N is even, then k=(N-2)/2, and a zero diagonal entry
is tacked onto the end.
Diagonal types. The diagonal consists of NZ1 zeros, then
k=N-NZ1-NZ2 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^(k-1)=RCOND
= 8: 1, 1-d, 1-2*d, ..., 1-(k-1)*d=RCOND
= 9: random numbers chosen from (RCOND,1)
= 10: random numbers with distribution IDIST (see ZLARND.)
N
N is INTEGER
The order of the matrix.
NZ1
NZ1 is INTEGER
If abs(ITYPE) > 3, then the first NZ1 diagonal entries will
be zero.
NZ2
NZ2 is INTEGER
If abs(ITYPE) > 3, then the last NZ2 diagonal entries will
be zero.
RSIGN
RSIGN is LOGICAL
= .TRUE.: The diagonal and subdiagonal entries will be
multiplied by random numbers of magnitude 1.
= .FALSE.: The diagonal and subdiagonal entries will be
left as they are (usually non-negative real.)
AMAGN
AMAGN is DOUBLE PRECISION
The diagonal and subdiagonal entries will be multiplied by
AMAGN.
RCOND
RCOND is DOUBLE PRECISION
If abs(ITYPE) > 4, then the smallest diagonal entry will be
RCOND. RCOND must be between 0 and 1.
TRIANG
TRIANG is DOUBLE PRECISION
The entries above the diagonal will be random numbers with
magnitude bounded by TRIANG (i.e., random numbers multiplied
by TRIANG.)
IDIST
IDIST is INTEGER
On entry, DIST specifies the type of distribution to be used
to generate a random matrix .
= 1: real and imaginary parts each UNIFORM( 0, 1 )
= 2: real and imaginary parts each UNIFORM( -1, 1 )
= 3: real and imaginary parts each NORMAL( 0, 1 )
= 4: complex number uniform in DISK( 0, 1 )
ISEED
ISEED 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 ZLATM4 to continue the same
random number sequence.
Note: ISEED(4) should be odd, for the random number generator
used at present.
A
A is COMPLEX*16 array, dimension (LDA, N)
Array to be computed.
LDA
LDA 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 zlctes (complex*16 Z, complex*16 D)
ZLCTES
Purpose:
ZLCTES returns .TRUE. if the eigenvalue Z/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 ZDRGES to test whether the driver
routine ZGGES successfully sorts eigenvalues.
Parameters:
Z
Z is COMPLEX*16
The numerator part of a complex eigenvalue Z/D.
D
D is COMPLEX*16
The denominator part of a complex eigenvalue Z/D.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
logical function zlctsx (complex*16 ALPHA, complex*16 BETA)
ZLCTSX
Purpose:
This function is used to determine what eigenvalues will be
selected. If this is part of the test driver ZDRGSX, do not
change the code UNLESS you are testing input examples and not
using the built-in examples.
Parameters:
ALPHA
ALPHA is COMPLEX*16
BETA
BETA is COMPLEX*16
parameters to decide whether the pair (ALPHA, BETA) is
selected.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlsets (integer M, integer P, integer N, complex*16, dimension( lda, * ) A,
complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( ldb, * ) B,
complex*16, dimension( ldb, * ) BF, integer LDB, complex*16, dimension( * ) C, complex*16,
dimension( * ) CF, complex*16, dimension( * ) D, complex*16, dimension( * ) DF,
complex*16, dimension( * ) X, complex*16, dimension( lwork ) WORK, integer LWORK, double
precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
ZLSETS
Purpose:
ZLSETS tests ZGGLSE - 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.
P
P is INTEGER
The number of rows of the matrix B. P >= 0.
N
N is INTEGER
The number of columns of the matrices A and B. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The M-by-N matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and R.
LDA >= max(M,N).
B
B is COMPLEX*16 array, dimension (LDB,N)
The P-by-N matrix A.
BF
BF is COMPLEX*16 array, dimension (LDB,N)
LDB
LDB is INTEGER
The leading dimension of the arrays B, BF, V and S.
LDB >= max(P,N).
C
C is COMPLEX*16 array, dimension( M )
the vector C in the LSE problem.
CF
CF is COMPLEX*16 array, dimension( M )
D
D is COMPLEX*16 array, dimension( P )
the vector D in the LSE problem.
DF
DF is COMPLEX*16 array, dimension( P )
X
X is COMPLEX*16 array, dimension( N )
solution vector X in the LSE problem.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT 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 zsbmv (character UPLO, integer N, integer K, complex*16 ALPHA, complex*16,
dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) X, integer INCX, complex*16
BETA, complex*16, dimension( * ) Y, integer INCY)
ZSBMV
Purpose:
ZSBMV performs the matrix-vector operation
y := alpha*A*x + beta*y,
where alpha and beta are scalars, x and y are n element vectors and
A is an n by n symmetric band matrix, with k super-diagonals.
UPLO - CHARACTER*1
On entry, UPLO specifies whether the upper or lower
triangular part of the band matrix A is being supplied as
follows:
UPLO = 'U' or 'u' The upper triangular part of A is
being supplied.
UPLO = 'L' or 'l' The lower triangular part of A is
being supplied.
Unchanged on exit.
N - INTEGER
On entry, N specifies the order of the matrix A.
N must be at least zero.
Unchanged on exit.
K - INTEGER
On entry, K specifies the number of super-diagonals of the
matrix A. K must satisfy 0 .le. K.
Unchanged on exit.
ALPHA - COMPLEX*16
On entry, ALPHA specifies the scalar alpha.
Unchanged on exit.
A - COMPLEX*16 array, dimension( LDA, N )
Before entry with UPLO = 'U' or 'u', the leading ( k + 1 )
by n part of the array A must contain the upper triangular
band part of the symmetric matrix, supplied column by
column, with the leading diagonal of the matrix in row
( k + 1 ) of the array, the first super-diagonal starting at
position 2 in row k, and so on. The top left k by k triangle
of the array A is not referenced.
The following program segment will transfer the upper
triangular part of a symmetric band matrix from conventional
full matrix storage to band storage:
DO 20, J = 1, N
M = K + 1 - J
DO 10, I = MAX( 1, J - K ), J
A( M + I, J ) = matrix( I, J )
10 CONTINUE
20 CONTINUE
Before entry with UPLO = 'L' or 'l', the leading ( k + 1 )
by n part of the array A must contain the lower triangular
band part of the symmetric matrix, supplied column by
column, with the leading diagonal of the matrix in row 1 of
the array, the first sub-diagonal starting at position 1 in
row 2, and so on. The bottom right k by k triangle of the
array A is not referenced.
The following program segment will transfer the lower
triangular part of a symmetric band matrix from conventional
full matrix storage to band storage:
DO 20, J = 1, N
M = 1 - J
DO 10, I = J, MIN( N, J + K )
A( M + I, J ) = matrix( I, J )
10 CONTINUE
20 CONTINUE
Unchanged on exit.
LDA - INTEGER
On entry, LDA specifies the first dimension of A as declared
in the calling (sub) program. LDA must be at least
( k + 1 ).
Unchanged on exit.
X - COMPLEX*16 array, dimension at least
( 1 + ( N - 1 )*abs( INCX ) ).
Before entry, the incremented array X must contain the
vector x.
Unchanged on exit.
INCX - INTEGER
On entry, INCX specifies the increment for the elements of
X. INCX must not be zero.
Unchanged on exit.
BETA - COMPLEX*16
On entry, BETA specifies the scalar beta.
Unchanged on exit.
Y - COMPLEX*16 array, dimension at least
( 1 + ( N - 1 )*abs( INCY ) ).
Before entry, the incremented array Y must contain the
vector y. On exit, Y is overwritten by the updated vector y.
INCY - INTEGER
On entry, INCY specifies the increment for the elements of
Y. INCY must not be zero.
Unchanged on exit.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zsgt01 (integer ITYPE, character UPLO, integer N, integer M, complex*16, dimension(
lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer LDB, complex*16,
dimension( ldz, * ) Z, integer LDZ, double precision, dimension( * ) D, complex*16,
dimension( * ) WORK, double precision, dimension( * ) RWORK, double precision, dimension(
* ) RESULT)
ZSGT01
Purpose:
CDGT01 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 Hermitian matrix, B is Hermitian positive definite,
Z is unitary, 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 Hermitian generalized eigenproblem.
= 1: A*z = (lambda)*B*z
= 2: A*B*z = (lambda)*z
= 3: B*A*z = (lambda)*z
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrices A and B is stored.
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
M
M is INTEGER
The number of eigenvalues found. M >= 0.
A
A is COMPLEX*16 array, dimension (LDA, N)
The original Hermitian matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB, N)
The original Hermitian positive definite matrix B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
Z
Z is COMPLEX*16 array, dimension (LDZ, M)
The computed eigenvectors of the generalized eigenproblem.
LDZ
LDZ is INTEGER
The leading dimension of the array Z. LDZ >= max(1,N).
D
D is DOUBLE PRECISION array, dimension (M)
The computed eigenvalues of the generalized eigenproblem.
WORK
WORK is COMPLEX*16 array, dimension (N*N)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESULT
RESULT 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 zslect (complex*16 Z)
ZSLECT
Purpose:
ZSLECT returns .TRUE. if the eigenvalue Z is to be selected,
otherwise it returns .FALSE.
It is used by ZCHK41 to test if ZGEES successfully sorts eigenvalues,
and by ZCHK43 to test if ZGEESX successfully sorts eigenvalues.
The common block /SSLCT/ controls how eigenvalues are selected.
If SELOPT = 0, then ZSLECT return .TRUE. when real(Z) is less than
zero, and .FALSE. otherwise.
If SELOPT is at least 1, ZSLECT returns SELVAL(SELOPT) and adds 1
to SELOPT, cycling back to 1 at SELMAX.
Parameters:
Z
Z is COMPLEX*16
The eigenvalue Z.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zstt21 (integer N, integer KBAND, double precision, dimension( * ) AD, double
precision, dimension( * ) AE, double precision, dimension( * ) SD, double precision,
dimension( * ) SE, complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension(
* ) WORK, double precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
ZSTT21
Purpose:
ZSTT21 checks a decomposition of the form
A = U S UC>
where * means conjugate transpose, A is real symmetric tridiagonal,
U is unitary, and S is real and 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, ZSTT21 does nothing.
It must be at least zero.
KBAND
KBAND 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 tri-diagonal.
AD
AD is DOUBLE PRECISION array, dimension (N)
The diagonal of the original (unfactored) matrix A. A is
assumed to be real symmetric tridiagonal.
AE
AE is DOUBLE PRECISION array, dimension (N-1)
The off-diagonal 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.
SD
SD is DOUBLE PRECISION array, dimension (N)
The diagonal of the real (symmetric tri-) diagonal matrix S.
SE
SE is DOUBLE PRECISION array, dimension (N-1)
The off-diagonal 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.
U
U is COMPLEX*16 array, dimension (LDU, N)
The unitary matrix in the decomposition.
LDU
LDU is INTEGER
The leading dimension of U. LDU must be at least N.
WORK
WORK is COMPLEX*16 array, dimension (N**2)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESULT
RESULT 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 zstt22 (integer N, integer M, integer KBAND, double precision, dimension( * ) AD,
double precision, dimension( * ) AE, double precision, dimension( * ) SD, double
precision, dimension( * ) SE, complex*16, dimension( ldu, * ) U, integer LDU, complex*16,
dimension( ldwork, * ) WORK, integer LDWORK, double precision, dimension( * ) RWORK,
double precision, dimension( 2 ) RESULT)
ZSTT22
Purpose:
ZSTT22 checks a set of M eigenvalues and eigenvectors,
A U = U S
where A is Hermitian tridiagonal, the columns of U are unitary,
and S is diagonal (if KBAND=0) or Hermitian 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, ZSTT22 does nothing.
It must be at least zero.
M
M is INTEGER
The number of eigenpairs to check. If it is zero, ZSTT22
does nothing. It must be at least zero.
KBAND
KBAND 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 Hermitian tri-diagonal.
AD
AD is DOUBLE PRECISION array, dimension (N)
The diagonal of the original (unfactored) matrix A. A is
assumed to be Hermitian tridiagonal.
AE
AE is DOUBLE PRECISION array, dimension (N)
The off-diagonal of the original (unfactored) matrix A. A
is assumed to be Hermitian tridiagonal. AE(1) is ignored,
AE(2) is the (1,2) and (2,1) element, etc.
SD
SD is DOUBLE PRECISION array, dimension (N)
The diagonal of the (Hermitian tri-) diagonal matrix S.
SE
SE is DOUBLE PRECISION array, dimension (N)
The off-diagonal of the (Hermitian 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.
U
U is DOUBLE PRECISION array, dimension (LDU, N)
The unitary matrix in the decomposition.
LDU
LDU is INTEGER
The leading dimension of U. LDU must be at least N.
WORK
WORK is COMPLEX*16 array, dimension (LDWORK, M+1)
LDWORK
LDWORK is INTEGER
The leading dimension of WORK. LDWORK must be at least
max(1,M).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESULT
RESULT 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 zunt01 (character ROWCOL, integer M, integer N, complex*16, dimension( ldu, * ) U,
integer LDU, complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension(
* ) RWORK, double precision RESID)
ZUNT01
Purpose:
ZUNT01 checks that the matrix U is unitary 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
M
M is INTEGER
The number of rows of the matrix U.
N
N is INTEGER
The number of columns of the matrix U.
U
U is COMPLEX*16 array, dimension (LDU,N)
The unitary 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'.
LDU
LDU is INTEGER
The leading dimension of the array U. LDU >= max(1,M).
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. For best performance, LWORK
should be at least N*N if ROWCOL = 'C' or M*M if
ROWCOL = 'R', but the test will be done even if LWORK is 0.
RWORK
RWORK is DOUBLE PRECISION array, dimension (min(M,N))
Used only if LWORK is large enough to use the Level 3 BLAS
code.
RESID
RESID 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 zunt03 (character*( * ) RC, integer MU, integer MV, integer N, integer K,
complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension( ldv, * ) V, integer
LDV, complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension( * )
RWORK, double precision RESULT, integer INFO)
ZUNT03
Purpose:
ZUNT03 compares two unitary 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 abs(S) = 1 (chosen to minimize the expression), U(i) is the
i-th row (column) of U, and V(i) is the i-th 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.
MU
MU is INTEGER
The number of rows of U if RC = 'R', and the number of
columns if RC = 'C'. If MU = 0 ZUNT03 does nothing.
MU must be at least zero.
MV
MV is INTEGER
The number of rows of V if RC = 'R', and the number of
columns if RC = 'C'. If MV = 0 ZUNT03 does nothing.
MV must be at least zero.
N
N 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
ZUNT03 does nothing. N must be at least zero.
K
K is INTEGER
The number of rows or columns of U and V to compare.
0 <= K <= max(MU,MV).
U
U is COMPLEX*16 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.
LDU
LDU is INTEGER
The leading dimension of U. If RC = 'R', LDU >= max(1,MU),
and if RC = 'C', LDU >= max(1,N).
V
V is COMPLEX*16 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.
LDV
LDV is INTEGER
The leading dimension of V. If RC = 'R', LDV >= max(1,MV),
and if RC = 'C', LDV >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK 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.
RWORK
RWORK is DOUBLE PRECISION array, dimension (max(MV,N))
RESULT
RESULT is DOUBLE PRECISION
The value computed by the test described above. RESULT is
limited to 1/ulp to avoid overflow.
INFO
INFO is INTEGER
0 indicates a successful exit
-k indicates the k-th parameter had an illegal value
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.