complex16_eig(3) 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:

June 2016

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 original 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:

June 2016

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:

June 2016

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:

June 2016

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:

June 2016

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:

June 2016

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:

June 2016

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:

June 2016

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:

June 2016

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:

June 2016

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:

June 2016

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:

June 2016

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:

June 2016

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:

June 2016

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:

June 2016

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.