double_eig(3) double

Functions


subroutine cbdt05 (M, N, A, LDA, S, NS, U, LDU, VT, LDVT, WORK, RESID)

subroutine dbdt01 (M, N, KD, A, LDA, Q, LDQ, D, E, PT, LDPT, WORK, RESID)
DBDT01
subroutine dbdt02 (M, N, B, LDB, C, LDC, U, LDU, WORK, RESID)
DBDT02
subroutine dbdt03 (UPLO, N, KD, D, E, U, LDU, S, VT, LDVT, WORK, RESID)
DBDT03
subroutine dbdt04 (UPLO, N, D, E, S, NS, U, LDU, VT, LDVT, WORK, RESID)

subroutine dbdt05 (M, N, A, LDA, S, NS, U, LDU, VT, LDVT, WORK, RESID)

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

subroutine sbdt05 (M, N, A, LDA, S, NS, U, LDU, VT, LDVT, WORK, RESID)

subroutine zbdt05 (M, N, A, LDA, S, NS, U, LDU, VT, LDVT, WORK, RESID)

Detailed Description

This is the group of double LAPACK TESTING EIG routines.

Function Documentation

subroutine cbdt05 (integer M, integer N, complex, dimension( lda, * ) A, integer LDA, real, dimension( * ) S, integer NS, complex, dimension( * ) U, integer LDU, complex, dimension( ldvt, * ) VT, integer LDVT, complex, dimension( * ) WORK, real RESID)

Purpose:

CBDT05 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.

The test ratio to test the singular value decomposition is RESID = norm( S - U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.

Parameters:

M

          M is INTEGER
          The number of rows of the matrices A and U.


N

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


A

          A is COMPLEX array, dimension (LDA,N)
          The m by n matrix A.
 
aram[in] LDA leading dimension of the array A. LDA >= max(1,M).


S

          S is REAL array, dimension (NS)
          The singular values from the (partial) SVD of B, sorted in 
          decreasing order.


NS

          NS is INTEGER
          The number of singular values/vectors from the (partial) 
          SVD of B.


U

          U is COMPLEX array, dimension (LDU,NS)
          The n by ns orthogonal matrix U in S = U' * B * V.


LDU

          LDU is INTEGER
          The leading dimension of the array U.  LDU >= max(1,N)


VT

          VT is COMPLEX array, dimension (LDVT,N)
          The n by ns orthogonal matrix V in S = U' * B * V.


LDVT

          LDVT is INTEGER
          The leading dimension of the array VT.


WORK

          WORK is COMPLEX array, dimension (M,N)


RESID

          RESID is REAL
          The test ratio:  norm(S - U' * A * V) / ( n * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dbdt01 (integer M, integer N, integer KD, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldpt, * ) PT, integer LDPT, double precision, dimension( * ) WORK, double precision RESID)

DBDT01

Purpose:

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


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrices A and Q.


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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDQ,N)
          The m by min(m,n) orthogonal 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 DOUBLE PRECISION array, dimension (LDPT,N)
          The min(m,n) by n orthogonal 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 DOUBLE PRECISION array, dimension (M+N)


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 dbdt02 (integer M, integer N, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( ldc, * ) C, integer LDC, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) WORK, double precision RESID)

DBDT02

Purpose:

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


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrices B and C and the order of
          the matrix Q.


N

          N is INTEGER
          The number of columns of the matrices B and C.


B

          B is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 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 dbdt03 (character UPLO, integer N, integer KD, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) S, double precision, dimension( ldvt, * ) VT, integer LDVT, double precision, dimension( * ) WORK, double precision RESID)

DBDT03

Purpose:

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


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix B is upper or lower bidiagonal.
          = 'U':  Upper bidiagonal
          = 'L':  Lower bidiagonal


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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 dbdt04 (character UPLO, integer N, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( * ) S, integer NS, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldvt, * ) VT, integer LDVT, double precision, dimension( * ) WORK, double precision RESID)

Purpose:

DBDT04 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.

The test ratio to test the singular value decomposition is RESID = norm( S - U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix B is upper or lower bidiagonal.
          = 'U':  Upper bidiagonal
          = 'L':  Lower bidiagonal


N

          N is INTEGER
          The order of the matrix B.


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'.


S

          S is DOUBLE PRECISION array, dimension (NS)
          The singular values from the (partial) SVD of B, sorted in 
          decreasing order.


NS

          NS is INTEGER
          The number of singular values/vectors from the (partial) 
          SVD of B.


U

          U is DOUBLE PRECISION array, dimension (LDU,NS)
          The n by ns orthogonal matrix U in S = U' * B * V.


LDU

          LDU is INTEGER
          The leading dimension of the array U.  LDU >= max(1,N)


VT

          VT is DOUBLE PRECISION array, dimension (LDVT,N)
          The n by ns orthogonal matrix V in S = U' * B * V.


LDVT

          LDVT is INTEGER
          The leading dimension of the array VT.


WORK

          WORK is DOUBLE PRECISION array, dimension (2*N)


RESID

          RESID is DOUBLE PRECISION
          The test ratio:  norm(S - U' * B * V) / ( n * norm(B) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dbdt05 (integer M, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) S, integer NS, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldvt, * ) VT, integer LDVT, double precision, dimension( * ) WORK, double precision RESID)

Purpose:

DBDT05 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.

The test ratio to test the singular value decomposition is RESID = norm( S - U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.

Parameters:

M

          M is INTEGER
          The number of rows of the matrices A and U.


N

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


A

          A is DOUBLE PRECISION array, dimension (LDA,N)
          The m by n matrix A.
 
aram[in] LDA leading dimension of the array A. LDA >= max(1,M).


S

          S is DOUBLE PRECISION array, dimension (NS)
          The singular values from the (partial) SVD of B, sorted in 
          decreasing order.


NS

          NS is INTEGER
          The number of singular values/vectors from the (partial) 
          SVD of B.


U

          U is DOUBLE PRECISION array, dimension (LDU,NS)
          The n by ns orthogonal matrix U in S = U' * B * V.


LDU

          LDU is INTEGER
          The leading dimension of the array U.  LDU >= max(1,N)


VT

          VT is DOUBLE PRECISION array, dimension (LDVT,N)
          The n by ns orthogonal matrix V in S = U' * B * V.


LDVT

          LDVT is INTEGER
          The leading dimension of the array VT.


WORK

          WORK is DOUBLE PRECISION array, dimension (M,N)


RESID

          RESID is DOUBLE PRECISION
          The test ratio:  norm(S - U' * A * V) / ( n * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dchkbb (integer NSIZES, integer, dimension( * ) MVAL, integer, dimension( * ) NVAL, integer NWDTHS, integer, dimension( * ) KK, integer NTYPES, logical, dimension( * ) DOTYPE, integer NRHS, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldab, * ) AB, integer LDAB, double precision, dimension( * ) BD, double precision, dimension( * ) BE, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldp, * ) P, integer LDP, double precision, dimension( ldc, * ) C, integer LDC, double precision, dimension( ldc, * ) CC, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RESULT, integer INFO)

DCHKBB

Purpose:

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


 

Parameters:

NSIZES

          NSIZES is INTEGER
          The number of values of M and N contained in the vectors
          MVAL and NVAL.  The matrix sizes are used in pairs (M,N).
          If NSIZES is zero, DCHKBB does nothing.  NSIZES must be at
          least zero.


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,
          DCHKBB 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, DCHKBB
          does nothing.  It must be at least zero.  If it is MAXTYP+1
          and NSIZES is 1, then an additional type, MAXTYP+1 is
          defined, which is to use whatever matrix is in A.  This
          is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
          DOTYPE(MAXTYP+1) is .TRUE. .


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 DCHKBB 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 DGBBRD.


BE

          BE is DOUBLE PRECISION array, dimension (max(NN))
          Used to hold the off-diagonal of the bidiagonal matrix
          computed by DGBBRD.


Q

          Q is DOUBLE PRECISION array, dimension (LDQ, max(NN))
          Used to hold the orthogonal matrix Q computed by DGBBRD.


LDQ

          LDQ is INTEGER
          The leading dimension of Q.  It must be at least 1
          and at least max( NN ).


P

          P is DOUBLE PRECISION array, dimension (LDP, max(NN))
          Used to hold the orthogonal matrix P computed by DGBBRD.


LDP

          LDP is INTEGER
          The leading dimension of P.  It must be at least 1
          and at least max( NN ).


C

          C is DOUBLE PRECISION array, dimension (LDC, max(NN))
          Used to hold the matrix C updated by DGBBRD.


LDC

          LDC is INTEGER
          The leading dimension of U.  It must be at least 1
          and at least max( NN ).


CC

          CC is DOUBLE PRECISION array, dimension (LDC, max(NN))
          Used to hold a copy of the matrix C.


WORK

          WORK is DOUBLE PRECISION 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).


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 dchkbd (integer NSIZES, integer, dimension( * ) MVAL, integer, dimension( * ) NVAL, integer NTYPES, logical, dimension( * ) DOTYPE, integer NRHS, integer, dimension( 4 ) ISEED, double precision THRESH, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) BD, double precision, dimension( * ) BE, double precision, dimension( * ) S1, double precision, dimension( * ) S2, double precision, dimension( ldx, * ) X, integer LDX, double precision, dimension( ldx, * ) Y, double precision, dimension( ldx, * ) Z, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldpt, * ) PT, integer LDPT, double precision, dimension( ldpt, * ) U, double precision, dimension( ldpt, * ) VT, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer NOUT, integer INFO)

DCHKBD

Purpose:

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


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 DBDSQR.  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 DCHKBD 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDX,NRHS)


Z

          Z is DOUBLE PRECISION array, dimension (LDX,NRHS)


Q

          Q is DOUBLE PRECISION array, dimension (LDQ,MMAX)


LDQ

          LDQ is INTEGER
          The leading dimension of the array Q.  LDQ >= max(1,MMAX).


PT

          PT is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension
                      (LDPT,max(min(MVAL(j),NVAL(j))))


VT

          VT is DOUBLE PRECISION array, dimension
                      (LDPT,max(min(MVAL(j),NVAL(j))))


WORK

          WORK is DOUBLE PRECISION 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))


IWORK

          IWORK is INTEGER array, dimension at least 8*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: LDPT< 1 or LDPT< MNMAX.
          -27: LWORK too small.
          If  DLATMR, SLATMS, DGEBRD, DORGBR, or DBDSQR,
              returns an error code, the
              absolute value of it is returned.
-----------------------------------------------------------------------
     Some Local Variables and Parameters:
     ---- ----- --------- --- ----------
     ZERO, ONE       Real 0 and 1.
     MAXTYP          The number of types defined.
     NTEST           The number of tests performed, or which can
                     be performed so far, for the current matrix.
     MMAX            Largest value in NN.
     NMAX            Largest value in NN.
     MNMIN           min(MM(j), NN(j)) (the dimension of the bidiagonal
                     matrix.)
     MNMAX           The maximum value of MNMIN for j=1,...,NSIZES.
     NFAIL           The number of tests which have exceeded THRESH
     COND, IMODE     Values to be passed to the matrix generators.
     ANORM           Norm of A; passed to matrix generators.
     OVFL, UNFL      Overflow and underflow thresholds.
     RTOVFL, RTUNFL  Square roots of the previous 2 values.
     ULP, ULPINV     Finest relative precision and its inverse.
             The following four arrays decode JTYPE:
     KTYPE(j)        The general type (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 dchkbk (integer NIN, integer NOUT)

DCHKBK

Purpose:

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


 

Parameters:

NIN

          NIN is INTEGER
          The logical unit number for input.  NIN > 0.


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 dchkbl (integer NIN, integer NOUT)

DCHKBL

Purpose:

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


 

Parameters:

NIN

          NIN is INTEGER
          The logical unit number for input.  NIN > 0.


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 dchkec (double precision THRESH, logical TSTERR, integer NIN, integer NOUT)

DCHKEC

Purpose:

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


 

Parameters:

THRESH

          THRESH is DOUBLE PRECISION
          Threshold for residual tests.  A computed test ratio passes
          the threshold if it is less than THRESH.


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:

November 2011

program dchkee ()

DCHKEE

Purpose:

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


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

June 2016

subroutine dchkgg (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, logical TSTDIF, double precision THRSHN, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) H, double precision, dimension( lda, * ) T, double precision, dimension( lda, * ) S1, double precision, dimension( lda, * ) S2, double precision, dimension( lda, * ) P1, double precision, dimension( lda, * ) P2, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldu, * ) V, double precision, dimension( ldu, * ) Q, double precision, dimension( ldu, * ) Z, double precision, dimension( * ) ALPHR1, double precision, dimension( * ) ALPHI1, double precision, dimension( * ) BETA1, double precision, dimension( * ) ALPHR3, double precision, dimension( * ) ALPHI3, double precision, dimension( * ) BETA3, double precision, dimension( ldu, * ) EVECTL, double precision, dimension( ldu, * ) EVECTR, double precision, dimension( * ) WORK, integer LWORK, logical, dimension( * ) LLWORK, double precision, dimension( 15 ) RESULT, integer INFO)

DCHKGG

Purpose:

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


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 DCHKGG 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 DOUBLE PRECISION array, dimension
                            (LDA, max(NN))
          Used to hold the original A matrix.  Used as input only
          if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
          DOTYPE(MAXTYP+1)=.TRUE.


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 DOUBLE PRECISION array, dimension
                            (LDA, max(NN))
          Used to hold the original B matrix.  Used as input only
          if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
          DOTYPE(MAXTYP+1)=.TRUE.


H

          H is DOUBLE PRECISION array, dimension (LDA, max(NN))
          The upper Hessenberg matrix computed from A by DGGHRD.


T

          T is DOUBLE PRECISION array, dimension (LDA, max(NN))
          The upper triangular matrix computed from B by DGGHRD.


S1

          S1 is DOUBLE PRECISION array, dimension (LDA, max(NN))
          The Schur (block upper triangular) matrix computed from H by
          DHGEQZ when Q and Z are also computed.


S2

          S2 is DOUBLE PRECISION array, dimension (LDA, max(NN))
          The Schur (block upper triangular) matrix computed from H by
          DHGEQZ when Q and Z are not computed.


P1

          P1 is DOUBLE PRECISION array, dimension (LDA, max(NN))
          The upper triangular matrix computed from T by DHGEQZ
          when Q and Z are also computed.


P2

          P2 is DOUBLE PRECISION array, dimension (LDA, max(NN))
          The upper triangular matrix computed from T by DHGEQZ
          when Q and Z are not computed.


U

          U is DOUBLE PRECISION array, dimension (LDU, max(NN))
          The (left) orthogonal matrix computed by DGGHRD.


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 DOUBLE PRECISION array, dimension (LDU, max(NN))
          The (right) orthogonal matrix computed by DGGHRD.


Q

          Q is DOUBLE PRECISION array, dimension (LDU, max(NN))
          The (left) orthogonal matrix computed by DHGEQZ.


Z

          Z is DOUBLE PRECISION array, dimension (LDU, max(NN))
          The (left) orthogonal matrix computed by DHGEQZ.


ALPHR1

          ALPHR1 is DOUBLE PRECISION array, dimension (max(NN))


ALPHI1

          ALPHI1 is DOUBLE PRECISION array, dimension (max(NN))


BETA1

          BETA1 is DOUBLE PRECISION array, dimension (max(NN))
          The generalized eigenvalues of (A,B) computed by DHGEQZ
          when Q, Z, and the full Schur matrices are computed.
          On exit, ( ALPHR1(k)+ALPHI1(k)*i ) / BETA1(k) is the k-th
          generalized eigenvalue of the matrices in A and B.


ALPHR3

          ALPHR3 is DOUBLE PRECISION array, dimension (max(NN))


ALPHI3

          ALPHI3 is DOUBLE PRECISION array, dimension (max(NN))


BETA3

          BETA3 is DOUBLE PRECISION array, dimension (max(NN))


EVECTL

          EVECTL is DOUBLE PRECISION array, dimension (LDU, max(NN))
          The (block lower triangular) left eigenvector matrix for
          the matrices in S1 and P1.  (See DTGEVC for the format.)


EVECTR

          EVECTR is DOUBLE PRECISION array, dimension (LDU, max(NN))
          The (block upper triangular) right eigenvector matrix for
          the matrices in S1 and P1.  (See DTGEVC for the format.)


WORK

          WORK is DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The number of entries in WORK.  This must be at least
          max( 2 * N**2, 6*N, 1 ), for all N=NN(j).


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 dchkgk (integer NIN, integer NOUT)

DCHKGK

Purpose:

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


 

Parameters:

NIN

          NIN is INTEGER
          The logical unit number for input.  NIN > 0.


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 dchkgl (integer NIN, integer NOUT)

DCHKGL

Purpose:

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


 

Parameters:

NIN

          NIN is INTEGER
          The logical unit number for input.  NIN > 0.


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 dchkhs (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( lda, * ) T1, double precision, dimension( lda, * ) T2, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldu, * ) Z, double precision, dimension( ldu, * ) UZ, double precision, dimension( * ) WR1, double precision, dimension( * ) WI1, double precision, dimension( * ) WR2, double precision, dimension( * ) WI2, double precision, dimension( * ) WR3, double precision, dimension( * ) WI3, double precision, dimension( ldu, * ) EVECTL, double precision, dimension( ldu, * ) EVECTR, double precision, dimension( ldu, * ) EVECTY, double precision, dimension( ldu, * ) EVECTX, double precision, dimension( ldu, * ) UU, double precision, dimension( * ) TAU, double precision, dimension( * ) WORK, integer NWORK, integer, dimension( * ) IWORK, logical, dimension( * ) SELECT, double precision, dimension( 14 ) RESULT, integer INFO)

DCHKHS

Purpose:

    DCHKHS  checks the nonsymmetric eigenvalue problem routines.
            DGEHRD factors A as  U H U' , where ' means transpose,
            H is hessenberg, and U is an orthogonal matrix.
            DORGHR generates the orthogonal matrix U.
            DORMHR multiplies a matrix by the orthogonal matrix U.
            DHSEQR factors H as  Z T Z' , where Z is orthogonal and
            T is "quasi-triangular", and the eigenvalue vector W.
            DTREVC computes the left and right eigenvector matrices
            L and R for T.
            DHSEIN computes the left and right eigenvector matrices
            Y and X for H, using inverse iteration.
    When DCHKHS is called, a number of matrix "sizes" ("n's") and a
    number of matrix "types" are specified.  For each size ("n")
    and each type of matrix, one matrix will be generated and used
    to test the nonsymmetric eigenroutines.  For each matrix, 14
    tests will be performed:
    (1)     | A - U H U**T | / ( |A| n ulp )
    (2)     | I - UU**T | / ( n ulp )
    (3)     | H - Z T Z**T | / ( |H| n ulp )
    (4)     | I - ZZ**T | / ( n ulp )
    (5)     | A - UZ H (UZ)**T | / ( |A| n ulp )
    (6)     | I - UZ (UZ)**T | / ( n ulp )
    (7)     | T(Z computed) - T(Z not computed) | / ( |T| ulp )
    (8)     | W(Z computed) - W(Z not computed) | / ( |W| ulp )
    (9)     | TR - RW | / ( |T| |R| ulp )
    (10)    | L**H T - W**H L | / ( |T| |L| ulp )
    (11)    | HX - XW | / ( |H| |X| ulp )
    (12)    | Y**H H - W**H Y | / ( |H| |Y| ulp )
    (13)    | AX - XW | / ( |A| |X| ulp )
    (14)    | Y**H A - W**H Y | / ( |A| |Y| ulp )
    The "sizes" are specified by an array NN(1:NSIZES); the value of
    each element NN(j) specifies one size.
    The "types" are specified by a logical array DOTYPE( 1:NTYPES );
    if DOTYPE(j) is .TRUE., then matrix type "j" will be generated.
    Currently, the list of possible types is:
    (1)  The zero matrix.
    (2)  The identity matrix.
    (3)  A (transposed) Jordan block, with 1's on the diagonal.
    (4)  A diagonal matrix with evenly spaced entries
         1, ..., ULP  and random signs.
         (ULP = (first number larger than 1) - 1 )
    (5)  A diagonal matrix with geometrically spaced entries
         1, ..., ULP  and random signs.
    (6)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
         and random signs.
    (7)  Same as (4), but multiplied by SQRT( overflow threshold )
    (8)  Same as (4), but multiplied by SQRT( underflow threshold )
    (9)  A matrix of the form  U' T U, where U is orthogonal and
         T has evenly spaced entries 1, ..., ULP with random signs
         on the diagonal and random O(1) entries in the upper
         triangle.
    (10) A matrix of the form  U' T U, where U is orthogonal and
         T has geometrically spaced entries 1, ..., ULP with random
         signs on the diagonal and random O(1) entries in the upper
         triangle.
    (11) A matrix of the form  U' T U, where U is orthogonal and
         T has "clustered" entries 1, ULP,..., ULP with random
         signs on the diagonal and random O(1) entries in the upper
         triangle.
    (12) A matrix of the form  U' T U, where U is orthogonal and
         T has real or complex conjugate paired eigenvalues randomly
         chosen from ( ULP, 1 ) and random O(1) entries in the upper
         triangle.
    (13) A matrix of the form  X' T X, where X has condition
         SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP
         with random signs on the diagonal and random O(1) entries
         in the upper triangle.
    (14) A matrix of the form  X' T X, where X has condition
         SQRT( ULP ) and T has geometrically spaced entries
         1, ..., ULP with random signs on the diagonal and random
         O(1) entries in the upper triangle.
    (15) A matrix of the form  X' T X, where X has condition
         SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP
         with random signs on the diagonal and random O(1) entries
         in the upper triangle.
    (16) A matrix of the form  X' T X, where X has condition
         SQRT( ULP ) and T has real or complex conjugate paired
         eigenvalues randomly chosen from ( ULP, 1 ) and random
         O(1) entries in the upper triangle.
    (17) Same as (16), but multiplied by SQRT( overflow threshold )
    (18) Same as (16), but multiplied by SQRT( underflow threshold )
    (19) Nonsymmetric matrix with random entries chosen from (-1,1).
    (20) Same as (19), but multiplied by SQRT( overflow threshold )
    (21) Same as (19), but multiplied by SQRT( underflow threshold )


 

  NSIZES - INTEGER
           The number of sizes of matrices to use.  If it is zero,
           DCHKHS does nothing.  It must be at least zero.
           Not modified.
  NN     - INTEGER array, dimension (NSIZES)
           An array containing the sizes to be used for the matrices.
           Zero values will be skipped.  The values must be at least
           zero.
           Not modified.
  NTYPES - INTEGER
           The number of elements in DOTYPE.   If it is zero, DCHKHS
           does nothing.  It must be at least zero.  If it is MAXTYP+1
           and NSIZES is 1, then an additional type, MAXTYP+1 is
           defined, which is to use whatever matrix is in A.  This
           is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
           DOTYPE(MAXTYP+1) is .TRUE. .
           Not modified.
  DOTYPE - LOGICAL array, dimension (NTYPES)
           If DOTYPE(j) is .TRUE., then for each size in NN a
           matrix of that size and of type j will be generated.
           If NTYPES is smaller than the maximum number of types
           defined (PARAMETER MAXTYP), then types NTYPES+1 through
           MAXTYP will not be generated.  If NTYPES is larger
           than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES)
           will be ignored.
           Not modified.
  ISEED  - INTEGER array, dimension (4)
           On entry ISEED specifies the seed of the random number
           generator. The array elements should be between 0 and 4095;
           if not they will be reduced mod 4096.  Also, ISEED(4) must
           be odd.  The random number generator uses a linear
           congruential sequence limited to small integers, and so
           should produce machine independent random numbers. The
           values of ISEED are changed on exit, and can be used in the
           next call to DCHKHS to continue the same random number
           sequence.
           Modified.
  THRESH - DOUBLE PRECISION
           A test will count as "failed" if the "error", computed as
           described above, exceeds THRESH.  Note that the error
           is scaled to be O(1), so THRESH should be a reasonably
           small multiple of 1, e.g., 10 or 100.  In particular,
           it should not depend on the precision (single vs. double)
           or the size of the matrix.  It must be at least zero.
           Not modified.
  NOUNIT - INTEGER
           The FORTRAN unit number for printing out error messages
           (e.g., if a routine returns IINFO not equal to 0.)
           Not modified.
  A      - DOUBLE PRECISION array, dimension (LDA,max(NN))
           Used to hold the matrix whose eigenvalues are to be
           computed.  On exit, A contains the last matrix actually
           used.
           Modified.
  LDA    - INTEGER
           The leading dimension of A, H, T1 and T2.  It must be at
           least 1 and at least max( NN ).
           Not modified.
  H      - DOUBLE PRECISION array, dimension (LDA,max(NN))
           The upper hessenberg matrix computed by DGEHRD.  On exit,
           H contains the Hessenberg form of the matrix in A.
           Modified.
  T1     - DOUBLE PRECISION array, dimension (LDA,max(NN))
           The Schur (="quasi-triangular") matrix computed by DHSEQR
           if Z is computed.  On exit, T1 contains the Schur form of
           the matrix in A.
           Modified.
  T2     - DOUBLE PRECISION array, dimension (LDA,max(NN))
           The Schur matrix computed by DHSEQR when Z is not computed.
           This should be identical to T1.
           Modified.
  LDU    - INTEGER
           The leading dimension of U, Z, UZ and UU.  It must be at
           least 1 and at least max( NN ).
           Not modified.
  U      - DOUBLE PRECISION array, dimension (LDU,max(NN))
           The orthogonal matrix computed by DGEHRD.
           Modified.
  Z      - DOUBLE PRECISION array, dimension (LDU,max(NN))
           The orthogonal matrix computed by DHSEQR.
           Modified.
  UZ     - DOUBLE PRECISION array, dimension (LDU,max(NN))
           The product of U times Z.
           Modified.
  WR1    - DOUBLE PRECISION array, dimension (max(NN))
  WI1    - DOUBLE PRECISION array, dimension (max(NN))
           The real and imaginary parts of the eigenvalues of A,
           as computed when Z is computed.
           On exit, WR1 + WI1*i are the eigenvalues of the matrix in A.
           Modified.
  WR2    - DOUBLE PRECISION array, dimension (max(NN))
  WI2    - DOUBLE PRECISION array, dimension (max(NN))
           The real and imaginary parts of the eigenvalues of A,
           as computed when T is computed but not Z.
           On exit, WR2 + WI2*i are the eigenvalues of the matrix in A.
           Modified.
  WR3    - DOUBLE PRECISION array, dimension (max(NN))
  WI3    - DOUBLE PRECISION array, dimension (max(NN))
           Like WR1, WI1, these arrays contain the eigenvalues of A,
           but those computed when DHSEQR only computes the
           eigenvalues, i.e., not the Schur vectors and no more of the
           Schur form than is necessary for computing the
           eigenvalues.
           Modified.
  EVECTL - DOUBLE PRECISION array, dimension (LDU,max(NN))
           The (upper triangular) left eigenvector matrix for the
           matrix in T1.  For complex conjugate pairs, the real part
           is stored in one row and the imaginary part in the next.
           Modified.
  EVEZTR - DOUBLE PRECISION array, dimension (LDU,max(NN))
           The (upper triangular) right eigenvector matrix for the
           matrix in T1.  For complex conjugate pairs, the real part
           is stored in one column and the imaginary part in the next.
           Modified.
  EVECTY - DOUBLE PRECISION array, dimension (LDU,max(NN))
           The left eigenvector matrix for the
           matrix in H.  For complex conjugate pairs, the real part
           is stored in one row and the imaginary part in the next.
           Modified.
  EVECTX - DOUBLE PRECISION array, dimension (LDU,max(NN))
           The right eigenvector matrix for the
           matrix in H.  For complex conjugate pairs, the real part
           is stored in one column and the imaginary part in the next.
           Modified.
  UU     - DOUBLE PRECISION array, dimension (LDU,max(NN))
           Details of the orthogonal matrix computed by DGEHRD.
           Modified.
  TAU    - DOUBLE PRECISION array, dimension(max(NN))
           Further details of the orthogonal matrix computed by DGEHRD.
           Modified.
  WORK   - DOUBLE PRECISION array, dimension (NWORK)
           Workspace.
           Modified.
  NWORK  - INTEGER
           The number of entries in WORK.  NWORK >= 4*NN(j)*NN(j) + 2.
  IWORK  - INTEGER array, dimension (max(NN))
           Workspace.
           Modified.
  SELECT - LOGICAL array, dimension (max(NN))
           Workspace.
           Modified.
  RESULT - DOUBLE PRECISION array, dimension (14)
           The values computed by the fourteen tests described above.
           The values are currently limited to 1/ulp, to avoid
           overflow.
           Modified.
  INFO   - INTEGER
           If 0, then everything ran OK.
            -1: NSIZES < 0
            -2: Some NN(j) < 0
            -3: NTYPES < 0
            -6: THRESH < 0
            -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).
           -14: LDU < 1 or LDU < NMAX.
           -28: NWORK too small.
           If  DLATMR, SLATMS, or SLATME returns an error code, the
               absolute value of it is returned.
           If 1, then DHSEQR could not find all the shifts.
           If 2, then the EISPACK code (for small blocks) failed.
           If >2, then 30*N iterations were not enough to find an
               eigenvalue or to decompose the problem.
           Modified.
-----------------------------------------------------------------------
     Some Local Variables and Parameters:
     ---- ----- --------- --- ----------
     ZERO, ONE       Real 0 and 1.
     MAXTYP          The number of types defined.
     MTEST           The number of tests defined: care must be taken
                     that (1) the size of RESULT, (2) the number of
                     tests actually performed, and (3) MTEST agree.
     NTEST           The number of tests performed on this matrix
                     so far.  This should be less than MTEST, and
                     equal to it by the last test.  It will be less
                     if any of the routines being tested indicates
                     that it could not compute the matrices that
                     would be tested.
     NMAX            Largest value in NN.
     NMATS           The number of matrices generated so far.
     NERRS           The number of tests which have exceeded THRESH
                     so far (computed by DLAFTS).
     COND, CONDS,
     IMODE           Values to be passed to the matrix generators.
     ANORM           Norm of A; passed to matrix generators.
     OVFL, UNFL      Overflow and underflow thresholds.
     ULP, ULPINV     Finest relative precision and its inverse.
     RTOVFL, RTUNFL,
     RTULP, RTULPI   Square roots of the previous 4 values.
             The following four arrays decode JTYPE:
     KTYPE(j)        The general type (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 2015

subroutine dchksb (integer NSIZES, integer, dimension( * ) NN, integer NWDTHS, integer, dimension( * ) KK, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) SD, double precision, dimension( * ) SE, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RESULT, integer INFO)

DCHKSB

Purpose:

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


 

Parameters:

NSIZES

          NSIZES is INTEGER
          The number of sizes of matrices to use.  If it is zero,
          DCHKSB does nothing.  It must be at least zero.


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,
          DCHKSB 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, DCHKSB
          does nothing.  It must be at least zero.  If it is MAXTYP+1
          and NSIZES is 1, then an additional type, MAXTYP+1 is
          defined, which is to use whatever matrix is in A.  This
          is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
          DOTYPE(MAXTYP+1) is .TRUE. .


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 DCHKSB 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 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 DSBTRD.


SE

          SE is DOUBLE PRECISION array, dimension (max(NN))
          Used to hold the off-diagonal of the tridiagonal matrix
          computed by DSBTRD.


U

          U is DOUBLE PRECISION array, dimension (LDU, max(NN))
          Used to hold the orthogonal matrix computed by DSBTRD.


LDU

          LDU is INTEGER
          The leading dimension of U.  It must be at least 1
          and at least max( NN ).


WORK

          WORK is DOUBLE PRECISION 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).


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 dchkst (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) AP, double precision, dimension( * ) SD, double precision, dimension( * ) SE, double precision, dimension( * ) D1, double precision, dimension( * ) D2, double precision, dimension( * ) D3, double precision, dimension( * ) D4, double precision, dimension( * ) D5, double precision, dimension( * ) WA1, double precision, dimension( * ) WA2, double precision, dimension( * ) WA3, double precision, dimension( * ) WR, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldu, * ) V, double precision, dimension( * ) VP, double precision, dimension( * ) TAU, double precision, dimension( ldu, * ) Z, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, double precision, dimension( * ) RESULT, integer INFO)

DCHKST

Purpose:

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


 

Parameters:

NSIZES

          NSIZES is INTEGER
          The number of sizes of matrices to use.  If it is zero,
          DCHKST does nothing.  It must be at least zero.


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, DCHKST
          does nothing.  It must be at least zero.  If it is MAXTYP+1
          and NSIZES is 1, then an additional type, MAXTYP+1 is
          defined, which is to use whatever matrix is in A.  This
          is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
          DOTYPE(MAXTYP+1) is .TRUE. .


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 DCHKST 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 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 DOUBLE PRECISION 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 DSYTRD.
          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
          DSYTRD.  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 DSTEQR 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 DSTEQR 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 DPTEQR(V).
          DPTEQR 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 DPTEQR(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 DOUBLE PRECISION array of
                             dimension( LDU, max(NN) ).
          The orthogonal matrix computed by DSYTRD + DORGTR.


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 DOUBLE PRECISION array of
                             dimension( LDU, max(NN) ).
          The Housholder vectors computed by DSYTRD in reducing A to
          tridiagonal form.  The vectors computed with UPLO='U' are
          in the upper triangle, and the vectors computed with UPLO='L'
          are in the lower triangle.  (As described in DSYTRD, the
          sub- and superdiagonal are not set to 1, although the
          true Householder vector has a 1 in that position.  The
          routines that use V, such as DORGTR, set those entries to
          1 before using them, and then restore them later.)


VP

          VP is DOUBLE PRECISION array of
                      dimension( max(NN)*max(NN+1)/2 )
          The matrix V stored in packed format.


TAU

          TAU is DOUBLE PRECISION array of
                             dimension( max(NN) )
          The Householder factors computed by DSYTRD in reducing A
          to tridiagonal form.


Z

          Z is DOUBLE PRECISION array of
                             dimension( LDU, max(NN) ).
          The orthogonal matrix of eigenvectors computed by DSTEQR,
          DPTEQR, and DSTEIN.


WORK

          WORK is DOUBLE PRECISION 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.


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  DLATMR, SLATMS, DSYTRD, DORGTR, DSTEQR, SSTERF,
              or DORMC2 returns an error code, the
              absolute value of it is returned.
-----------------------------------------------------------------------
       Some Local Variables and Parameters:
       ---- ----- --------- --- ----------
       ZERO, ONE       Real 0 and 1.
       MAXTYP          The number of types defined.
       NTEST           The number of tests performed, or which can
                       be performed so far, for the current matrix.
       NTESTT          The total number of tests performed so far.
       NBLOCK          Blocksize as returned by ENVIR.
       NMAX            Largest value in NN.
       NMATS           The number of matrices generated so far.
       NERRS           The number of tests which have exceeded THRESH
                       so far.
       COND, IMODE     Values to be passed to the matrix generators.
       ANORM           Norm of A; passed to matrix generators.
       OVFL, UNFL      Overflow and underflow thresholds.
       ULP, ULPINV     Finest relative precision and its inverse.
       RTOVFL, RTUNFL  Square roots of the previous 2 values.
               The following four arrays decode JTYPE:
       KTYPE(j)        The general type (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 dckcsd (integer NM, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL, integer, dimension( * ) QVAL, integer NMATS, integer, dimension( 4 ) ISEED, double precision THRESH, integer MMAX, double precision, dimension( * ) X, double precision, dimension( * ) XF, double precision, dimension( * ) U1, double precision, dimension( * ) U2, double precision, dimension( * ) V1T, double precision, dimension( * ) V2T, double precision, dimension( * ) THETA, integer, dimension( * ) IWORK, double precision, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)

DCKCSD

Purpose:

 DCKCSD tests DORCSD:
        the CSD for an M-by-M orthogonal 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 DOUBLE PRECISION array, dimension (MMAX*MMAX)


XF

          XF is DOUBLE PRECISION array, dimension (MMAX*MMAX)


U1

          U1 is DOUBLE PRECISION array, dimension (MMAX*MMAX)


U2

          U2 is DOUBLE PRECISION array, dimension (MMAX*MMAX)


V1T

          V1T is DOUBLE PRECISION array, dimension (MMAX*MMAX)


V2T

          V2T is DOUBLE PRECISION array, dimension (MMAX*MMAX)


THETA

          THETA is DOUBLE PRECISION array, dimension (MMAX)


IWORK

          IWORK is INTEGER array, dimension (MMAX)


WORK

          WORK is DOUBLE PRECISION 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 DLAROR returns an error code, the absolute value
                 of it is returned.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dckglm (integer NN, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL, integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double precision THRESH, integer NMAX, double precision, dimension( * ) A, double precision, dimension( * ) AF, double precision, dimension( * ) B, double precision, dimension( * ) BF, double precision, dimension( * ) X, double precision, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)

DCKGLM

Purpose:

 DCKGLM tests DGGGLM - subroutine for solving generalized linear
                       model problem.


 

Parameters:

NN

          NN is INTEGER
          The number of values of N, M and P contained in the vectors
          NVAL, MVAL and PVAL.


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.


NVAL

          NVAL is INTEGER array, dimension (NN)
          The values of the matrix 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 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 DOUBLE PRECISION array, dimension (NMAX*NMAX)


AF

          AF is DOUBLE PRECISION array, dimension (NMAX*NMAX)


B

          B is DOUBLE PRECISION array, dimension (NMAX*NMAX)


BF

          BF is DOUBLE PRECISION array, dimension (NMAX*NMAX)


X

          X is DOUBLE PRECISION array, dimension (4*NMAX)


RWORK

          RWORK is DOUBLE PRECISION array, dimension (NMAX)


WORK

          WORK is DOUBLE PRECISION 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 DLATMS returns an error code, the absolute value
                 of it is returned.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dckgqr (integer NM, integer, dimension( * ) MVAL, integer NP, integer, dimension( * ) PVAL, integer NN, integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double precision THRESH, integer NMAX, double precision, dimension( * ) A, double precision, dimension( * ) AF, double precision, dimension( * ) AQ, double precision, dimension( * ) AR, double precision, dimension( * ) TAUA, double precision, dimension( * ) B, double precision, dimension( * ) BF, double precision, dimension( * ) BZ, double precision, dimension( * ) BT, double precision, dimension( * ) BWK, double precision, dimension( * ) TAUB, double precision, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)

DCKGQR

Purpose:

 DCKGQR tests
 DGGQRF: GQR factorization for N-by-M matrix A and N-by-P matrix B,
 DGGRQF: 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 DOUBLE PRECISION array, dimension (NMAX*NMAX)


AF

          AF is DOUBLE PRECISION array, dimension (NMAX*NMAX)


AQ

          AQ is DOUBLE PRECISION array, dimension (NMAX*NMAX)


AR

          AR is DOUBLE PRECISION array, dimension (NMAX*NMAX)


TAUA

          TAUA is DOUBLE PRECISION array, dimension (NMAX)


B

          B is DOUBLE PRECISION array, dimension (NMAX*NMAX)


BF

          BF is DOUBLE PRECISION array, dimension (NMAX*NMAX)


BZ

          BZ is DOUBLE PRECISION array, dimension (NMAX*NMAX)


BT

          BT is DOUBLE PRECISION array, dimension (NMAX*NMAX)


BWK

          BWK is DOUBLE PRECISION array, dimension (NMAX*NMAX)


TAUB

          TAUB is DOUBLE PRECISION array, dimension (NMAX)


WORK

          WORK is DOUBLE PRECISION 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 DLATMS returns an error code, the absolute value
                 of it is returned.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dckgsv (integer NM, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL, integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double precision THRESH, integer NMAX, double precision, dimension( * ) A, double precision, dimension( * ) AF, double precision, dimension( * ) B, double precision, dimension( * ) BF, double precision, dimension( * ) U, double precision, dimension( * ) V, double precision, dimension( * ) Q, double precision, dimension( * ) ALPHA, double precision, dimension( * ) BETA, double precision, dimension( * ) R, integer, dimension( * ) IWORK, double precision, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)

DCKGSV

Purpose:

 DCKGSV tests DGGSVD:
        the GSVD for 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 DOUBLE PRECISION array, dimension (NMAX*NMAX)


AF

          AF is DOUBLE PRECISION array, dimension (NMAX*NMAX)


B

          B is DOUBLE PRECISION array, dimension (NMAX*NMAX)


BF

          BF is DOUBLE PRECISION array, dimension (NMAX*NMAX)


U

          U is DOUBLE PRECISION array, dimension (NMAX*NMAX)


V

          V is DOUBLE PRECISION array, dimension (NMAX*NMAX)


Q

          Q is DOUBLE PRECISION array, dimension (NMAX*NMAX)


ALPHA

          ALPHA is DOUBLE PRECISION array, dimension (NMAX)


BETA

          BETA is DOUBLE PRECISION array, dimension (NMAX)


R

          R is DOUBLE PRECISION array, dimension (NMAX*NMAX)


IWORK

          IWORK is INTEGER array, dimension (NMAX)


WORK

          WORK is DOUBLE PRECISION 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 DLATMS returns an error code, the absolute value
                 of it is returned.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine dcklse (integer NN, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL, integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double precision THRESH, integer NMAX, double precision, dimension( * ) A, double precision, dimension( * ) AF, double precision, dimension( * ) B, double precision, dimension( * ) BF, double precision, dimension( * ) X, double precision, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)

DCKLSE

Purpose:

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


 

Parameters:

NN

          NN is INTEGER
          The number of values of (M,P,N) contained in the vectors
          (MVAL, PVAL, NVAL).


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 DOUBLE PRECISION array, dimension (NMAX*NMAX)


AF

          AF is DOUBLE PRECISION array, dimension (NMAX*NMAX)


B

          B is DOUBLE PRECISION array, dimension (NMAX*NMAX)


BF

          BF is DOUBLE PRECISION array, dimension (NMAX*NMAX)


X

          X is DOUBLE PRECISION array, dimension (5*NMAX)


WORK

          WORK is DOUBLE PRECISION 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 DLATMS returns an error code, the absolute value
                 of it is returned.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dcsdts (integer M, integer P, integer Q, double precision, dimension( ldx, * ) X, double precision, dimension( ldx, * ) XF, integer LDX, double precision, dimension( ldu1, * ) U1, integer LDU1, double precision, dimension( ldu2, * ) U2, integer LDU2, double precision, dimension( ldv1t, * ) V1T, integer LDV1T, double precision, dimension( ldv2t, * ) V2T, integer LDV2T, double precision, dimension( * ) THETA, integer, dimension( * ) IWORK, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 15 ) RESULT)

DCSDTS

Purpose:

 DCSDTS tests DORCSD, which, given an M-by-M partitioned orthogonal
 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 DORCSD2BY1, 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 DOUBLE PRECISION array, dimension (LDX,M)
          The M-by-M matrix X.


XF

          XF is DOUBLE PRECISION array, dimension (LDX,M)
          Details of the CSD of X, as returned by DORCSD;
          see DORCSD for further details.


LDX

          LDX is INTEGER
          The leading dimension of the arrays X and XF.
          LDX >= max( 1,M ).


U1

          U1 is DOUBLE PRECISION array, dimension(LDU1,P)
          The P-by-P orthogonal matrix U1.


LDU1

          LDU1 is INTEGER
          The leading dimension of the array U1. LDU >= max(1,P).


U2

          U2 is DOUBLE PRECISION array, dimension(LDU2,M-P)
          The (M-P)-by-(M-P) orthogonal matrix U2.


LDU2

          LDU2 is INTEGER
          The leading dimension of the array U2. LDU >= max(1,M-P).


V1T

          V1T is DOUBLE PRECISION array, dimension(LDV1T,Q)
          The Q-by-Q orthogonal matrix V1T.


LDV1T

          LDV1T is INTEGER
          The leading dimension of the array V1T. LDV1T >=
          max(1,Q).


V2T

          V2T is DOUBLE PRECISION array, dimension(LDV2T,M-Q)
          The (M-Q)-by-(M-Q) orthogonal 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 DORCSD for
          details.


IWORK

          IWORK is INTEGER array, dimension (M)


WORK

          WORK is DOUBLE PRECISION 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 2011

subroutine ddrges (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) S, double precision, dimension( lda, * ) T, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldq, * ) Z, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( 13 ) RESULT, logical, dimension( * ) BWORK, integer INFO)

DDRGES

Purpose:

 DDRGES checks the nonsymmetric generalized eigenvalue (Schur form)
 problem driver DGGES.
 DGGES factors A and B as Q S Z'  and Q T Z' , where ' means
 transpose, T is upper triangular, S is in generalized Schur form
 (block upper triangular, with 1x1 and 2x2 blocks on the diagonal,
 the 2x2 blocks corresponding to complex conjugate pairs of
 generalized eigenvalues), and Q and Z are orthogonal. It also
 computes the generalized eigenvalues (alpha(j),beta(j)), j=1,...,n,
 Thus, w(j) = alpha(j)/beta(j) is a root of the characteristic
 equation
                 det( A - w(j) B ) = 0
 Optionally it also reorder the eigenvalues so that a selected
 cluster of eigenvalues appears in the leading diagonal block of the
 Schur forms.
 When DDRGES is called, a number of matrix "sizes" ("N's") and a
 number of matrix "TYPES" are specified.  For each size ("N")
 and each TYPE of matrix, a pair of matrices (A, B) will be generated
 and used for testing. For each matrix pair, the following 13 tests
 will be performed and compared with the threshold THRESH except
 the tests (5), (11) and (13).
 (1)   | A - Q S Z' | / ( |A| n ulp ) (no sorting of eigenvalues)
 (2)   | B - Q T Z' | / ( |B| n ulp ) (no sorting of eigenvalues)
 (3)   | I - QQ' | / ( n ulp ) (no sorting of eigenvalues)
 (4)   | I - ZZ' | / ( n ulp ) (no sorting of eigenvalues)
 (5)   if A is in Schur form (i.e. quasi-triangular form)
       (no sorting of eigenvalues)
 (6)   if eigenvalues = diagonal blocks of the Schur form (S, T),
       i.e., test the maximum over j of D(j)  where:
       if alpha(j) is real:
                     |alpha(j) - S(j,j)|        |beta(j) - T(j,j)|
           D(j) = ------------------------ + -----------------------
                  max(|alpha(j)|,|S(j,j)|)   max(|beta(j)|,|T(j,j)|)
       if alpha(j) is complex:
                                 | det( s S - w T ) |
           D(j) = ---------------------------------------------------
                  ulp max( s norm(S), |w| norm(T) )*norm( s S - w T )
       and S and T are here the 2 x 2 diagonal blocks of S and T
       corresponding to the j-th and j+1-th eigenvalues.
       (no sorting of eigenvalues)
 (7)   | (A,B) - Q (S,T) Z' | / ( | (A,B) | n ulp )
            (with sorting of eigenvalues).
 (8)   | I - QQ' | / ( n ulp ) (with sorting of eigenvalues).
 (9)   | I - ZZ' | / ( n ulp ) (with sorting of eigenvalues).
 (10)  if A is in Schur form (i.e. quasi-triangular form)
       (with sorting of eigenvalues).
 (11)  if eigenvalues = diagonal blocks of the Schur form (S, T),
       i.e. test the maximum over j of D(j)  where:
       if alpha(j) is real:
                     |alpha(j) - S(j,j)|        |beta(j) - T(j,j)|
           D(j) = ------------------------ + -----------------------
                  max(|alpha(j)|,|S(j,j)|)   max(|beta(j)|,|T(j,j)|)
       if alpha(j) is complex:
                                 | det( s S - w T ) |
           D(j) = ---------------------------------------------------
                  ulp max( s norm(S), |w| norm(T) )*norm( s S - w T )
       and S and T are here the 2 x 2 diagonal blocks of S and T
       corresponding to the j-th and j+1-th eigenvalues.
       (with sorting of eigenvalues).
 (12)  if sorting worked and SDIM is the number of eigenvalues
       which were SELECTed.
 Test Matrices
 =============
 The sizes of the test matrices are specified by an array
 NN(1:NSIZES); the value of each element NN(j) specifies one size.
 The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if
 DOTYPE(j) is .TRUE., then matrix type "j" will be generated.
 Currently, the list of possible types is:
 (1)  ( 0, 0 )         (a pair of zero matrices)
 (2)  ( I, 0 )         (an identity and a zero matrix)
 (3)  ( 0, I )         (an identity and a zero matrix)
 (4)  ( I, I )         (a pair of identity matrices)
         t   t
 (5)  ( J , J  )       (a pair of transposed Jordan blocks)
                                     t                ( I   0  )
 (6)  ( X, Y )         where  X = ( J   0  )  and Y = (      t )
                                  ( 0   I  )          ( 0   J  )
                       and I is a k x k identity and J a (k+1)x(k+1)
                       Jordan block; k=(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 DOUBLE PRECISION array,
                                       dimension(LDA, max(NN))
          Used to hold the original A matrix.  Used as input only
          if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
          DOTYPE(MAXTYP+1)=.TRUE.


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 DOUBLE PRECISION array,
                                       dimension(LDA, max(NN))
          Used to hold the original B matrix.  Used as input only
          if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
          DOTYPE(MAXTYP+1)=.TRUE.


S

          S is DOUBLE PRECISION array, dimension (LDA, max(NN))
          The Schur form matrix computed from A by DGGES.  On exit, S
          contains the Schur form matrix corresponding to the matrix
          in A.


T

          T is DOUBLE PRECISION array, dimension (LDA, max(NN))
          The upper triangular matrix computed from B by DGGES.


Q

          Q is DOUBLE PRECISION array, dimension (LDQ, max(NN))
          The (left) orthogonal matrix computed by DGGES.


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 DOUBLE PRECISION array, dimension( LDQ, max(NN) )
          The (right) orthogonal matrix computed by DGGES.


ALPHAR

          ALPHAR is DOUBLE PRECISION array, dimension (max(NN))


ALPHAI

          ALPHAI is DOUBLE PRECISION array, dimension (max(NN))


BETA

          BETA is DOUBLE PRECISION array, dimension (max(NN))
          The generalized eigenvalues of (A,B) computed by DGGES.
          ( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the k-th
          generalized eigenvalue of A and B.


WORK

          WORK is DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.
          LWORK >= MAX( 10*(N+1), 3*N*N ), where N is the largest
          matrix dimension.


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 ddrges3 (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) S, double precision, dimension( lda, * ) T, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldq, * ) Z, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( 13 ) RESULT, logical, dimension( * ) BWORK, integer INFO)

DDRGES3

Purpose:

 DDRGES3 checks the nonsymmetric generalized eigenvalue (Schur form)
 problem driver DGGES3.
 DGGES3 factors A and B as Q S Z'  and Q T Z' , where ' means
 transpose, T is upper triangular, S is in generalized Schur form
 (block upper triangular, with 1x1 and 2x2 blocks on the diagonal,
 the 2x2 blocks corresponding to complex conjugate pairs of
 generalized eigenvalues), and Q and Z are orthogonal. It also
 computes the generalized eigenvalues (alpha(j),beta(j)), j=1,...,n,
 Thus, w(j) = alpha(j)/beta(j) is a root of the characteristic
 equation
                 det( A - w(j) B ) = 0
 Optionally it also reorder the eigenvalues so that a selected
 cluster of eigenvalues appears in the leading diagonal block of the
 Schur forms.
 When DDRGES3 is called, a number of matrix "sizes" ("N's") and a
 number of matrix "TYPES" are specified.  For each size ("N")
 and each TYPE of matrix, a pair of matrices (A, B) will be generated
 and used for testing. For each matrix pair, the following 13 tests
 will be performed and compared with the threshold THRESH except
 the tests (5), (11) and (13).
 (1)   | A - Q S Z' | / ( |A| n ulp ) (no sorting of eigenvalues)
 (2)   | B - Q T Z' | / ( |B| n ulp ) (no sorting of eigenvalues)
 (3)   | I - QQ' | / ( n ulp ) (no sorting of eigenvalues)
 (4)   | I - ZZ' | / ( n ulp ) (no sorting of eigenvalues)
 (5)   if A is in Schur form (i.e. quasi-triangular form)
       (no sorting of eigenvalues)
 (6)   if eigenvalues = diagonal blocks of the Schur form (S, T),
       i.e., test the maximum over j of D(j)  where:
       if alpha(j) is real:
                     |alpha(j) - S(j,j)|        |beta(j) - T(j,j)|
           D(j) = ------------------------ + -----------------------
                  max(|alpha(j)|,|S(j,j)|)   max(|beta(j)|,|T(j,j)|)
       if alpha(j) is complex:
                                 | det( s S - w T ) |
           D(j) = ---------------------------------------------------
                  ulp max( s norm(S), |w| norm(T) )*norm( s S - w T )
       and S and T are here the 2 x 2 diagonal blocks of S and T
       corresponding to the j-th and j+1-th eigenvalues.
       (no sorting of eigenvalues)
 (7)   | (A,B) - Q (S,T) Z' | / ( | (A,B) | n ulp )
            (with sorting of eigenvalues).
 (8)   | I - QQ' | / ( n ulp ) (with sorting of eigenvalues).
 (9)   | I - ZZ' | / ( n ulp ) (with sorting of eigenvalues).
 (10)  if A is in Schur form (i.e. quasi-triangular form)
       (with sorting of eigenvalues).
 (11)  if eigenvalues = diagonal blocks of the Schur form (S, T),
       i.e. test the maximum over j of D(j)  where:
       if alpha(j) is real:
                     |alpha(j) - S(j,j)|        |beta(j) - T(j,j)|
           D(j) = ------------------------ + -----------------------
                  max(|alpha(j)|,|S(j,j)|)   max(|beta(j)|,|T(j,j)|)
       if alpha(j) is complex:
                                 | det( s S - w T ) |
           D(j) = ---------------------------------------------------
                  ulp max( s norm(S), |w| norm(T) )*norm( s S - w T )
       and S and T are here the 2 x 2 diagonal blocks of S and T
       corresponding to the j-th and j+1-th eigenvalues.
       (with sorting of eigenvalues).
 (12)  if sorting worked and SDIM is the number of eigenvalues
       which were SELECTed.
 Test Matrices
 =============
 The sizes of the test matrices are specified by an array
 NN(1:NSIZES); the value of each element NN(j) specifies one size.
 The "types" are specified by a logical array DOTYPE( 1:NTYPES ); if
 DOTYPE(j) is .TRUE., then matrix type "j" will be generated.
 Currently, the list of possible types is:
 (1)  ( 0, 0 )         (a pair of zero matrices)
 (2)  ( I, 0 )         (an identity and a zero matrix)
 (3)  ( 0, I )         (an identity and a zero matrix)
 (4)  ( I, I )         (a pair of identity matrices)
         t   t
 (5)  ( J , J  )       (a pair of transposed Jordan blocks)
                                     t                ( I   0  )
 (6)  ( X, Y )         where  X = ( J   0  )  and Y = (      t )
                                  ( 0   I  )          ( 0   J  )
                       and I is a k x k identity and J a (k+1)x(k+1)
                       Jordan block; k=(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 DOUBLE PRECISION array,
                                       dimension(LDA, max(NN))
          Used to hold the original A matrix.  Used as input only
          if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
          DOTYPE(MAXTYP+1)=.TRUE.


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 DOUBLE PRECISION array,
                                       dimension(LDA, max(NN))
          Used to hold the original B matrix.  Used as input only
          if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
          DOTYPE(MAXTYP+1)=.TRUE.


S

          S is DOUBLE PRECISION array, dimension (LDA, max(NN))
          The Schur form matrix computed from A by DGGES3.  On exit, S
          contains the Schur form matrix corresponding to the matrix
          in A.


T

          T is DOUBLE PRECISION array, dimension (LDA, max(NN))
          The upper triangular matrix computed from B by DGGES3.


Q

          Q is DOUBLE PRECISION array, dimension (LDQ, max(NN))
          The (left) orthogonal matrix computed by DGGES3.


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 DOUBLE PRECISION array, dimension( LDQ, max(NN) )
          The (right) orthogonal matrix computed by DGGES3.


ALPHAR

          ALPHAR is DOUBLE PRECISION array, dimension (max(NN))


ALPHAI

          ALPHAI is DOUBLE PRECISION array, dimension (max(NN))


BETA

          BETA is DOUBLE PRECISION array, dimension (max(NN))
          The generalized eigenvalues of (A,B) computed by DGGES3.
          ( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the k-th
          generalized eigenvalue of A and B.


WORK

          WORK is DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.
          LWORK >= MAX( 10*(N+1), 3*N*N ), where N is the largest
          matrix dimension.


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 ddrgev (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) S, double precision, dimension( lda, * ) T, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldq, * ) Z, double precision, dimension( ldqe, * ) QE, integer LDQE, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( * ) ALPHR1, double precision, dimension( * ) ALPHI1, double precision, dimension( * ) BETA1, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RESULT, integer INFO)

DDRGEV

Purpose:

 DDRGEV checks the nonsymmetric generalized eigenvalue problem driver
 routine DGGEV.
 DGGEV computes for a pair of 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 DDRGEV is called, a number of matrix "sizes" ("n's") and a
 number of matrix "types" are specified.  For each size ("n")
 and each type of matrix, a pair of matrices (A, B) will be generated
 and used for testing.  For each matrix pair, the following tests
 will be performed and compared with the threshold THRESH.
 Results from DGGEV:
 (1)  max over all left eigenvalue/-vector pairs (alpha/beta,l) of
      | VL**H * (beta A - alpha B) |/( ulp max(|beta A|, |alpha B|) )
      where VL**H is the 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,
          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.  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.  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 DOUBLE PRECISION array,
                                       dimension(LDA, max(NN))
          Used to hold the original A matrix.  Used as input only
          if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
          DOTYPE(MAXTYP+1)=.TRUE.


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 DOUBLE PRECISION array,
                                       dimension(LDA, max(NN))
          Used to hold the original B matrix.  Used as input only
          if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
          DOTYPE(MAXTYP+1)=.TRUE.


S

          S is DOUBLE PRECISION array,
                                 dimension (LDA, max(NN))
          The Schur form matrix computed from A by DGGES.  On exit, S
          contains the Schur form matrix corresponding to the matrix
          in A.


T

          T is DOUBLE PRECISION array,
                                 dimension (LDA, max(NN))
          The upper triangular matrix computed from B by DGGES.


Q

          Q is DOUBLE PRECISION array,
                                 dimension (LDQ, max(NN))
          The (left) eigenvectors matrix computed by DGGEV.


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 DOUBLE PRECISION array, dimension( LDQ, max(NN) )
          The (right) orthogonal matrix computed by DGGES.


QE

          QE is DOUBLE PRECISION 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)).


ALPHAR

          ALPHAR is DOUBLE PRECISION array, dimension (max(NN))


ALPHAI

          ALPHAI is DOUBLE PRECISION array, dimension (max(NN))


BETA

          BETA is DOUBLE PRECISION array, dimension (max(NN))
          The generalized eigenvalues of (A,B) computed by DGGEV.
          ( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the k-th
          generalized eigenvalue of A and B.


ALPHR1

          ALPHR1 is DOUBLE PRECISION array, dimension (max(NN))


ALPHI1

          ALPHI1 is DOUBLE PRECISION array, dimension (max(NN))


BETA1

          BETA1 is DOUBLE PRECISION array, dimension (max(NN))
          Like ALPHAR, ALPHAI, BETA, these arrays contain the
          eigenvalues of A and B, but those computed when DGGEV only
          computes a partial eigendecomposition, i.e. not the
          eigenvalues and left and right eigenvectors.


WORK

          WORK is DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The number of entries in WORK.  LWORK >= MAX( 8*N, N*(N+1) ).


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 ddrgev3 (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) S, double precision, dimension( lda, * ) T, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( ldq, * ) Z, double precision, dimension( ldqe, * ) QE, integer LDQE, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( * ) ALPHR1, double precision, dimension( * ) ALPHI1, double precision, dimension( * ) BETA1, double precision, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RESULT, integer INFO)

DDRGEV3

Purpose:

 DDRGEV3 checks the nonsymmetric generalized eigenvalue problem driver
 routine DGGEV3.
 DGGEV3 computes for a pair of 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 DDRGEV3 is called, a number of matrix "sizes" ("n's") and a
 number of matrix "types" are specified.  For each size ("n")
 and each type of matrix, a pair of matrices (A, B) will be generated
 and used for testing.  For each matrix pair, the following tests
 will be performed and compared with the threshold THRESH.
 Results from DGGEV3:
 (1)  max over all left eigenvalue/-vector pairs (alpha/beta,l) of
      | VL**H * (beta A - alpha B) |/( ulp max(|beta A|, |alpha B|) )
      where VL**H is the 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,
          DDRGEV3 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, DDRGEV3
          does nothing.  It must be at least zero.  If it is MAXTYP+1
          and NSIZES is 1, then an additional type, MAXTYP+1 is
          defined, which is to use whatever matrix is in A.  This
          is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
          DOTYPE(MAXTYP+1) is .TRUE. .


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 DDRGEV3 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 DOUBLE PRECISION array,
                                       dimension(LDA, max(NN))
          Used to hold the original A matrix.  Used as input only
          if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
          DOTYPE(MAXTYP+1)=.TRUE.


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 DOUBLE PRECISION array,
                                       dimension(LDA, max(NN))
          Used to hold the original B matrix.  Used as input only
          if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
          DOTYPE(MAXTYP+1)=.TRUE.


S

          S is DOUBLE PRECISION array,
                                 dimension (LDA, max(NN))
          The Schur form matrix computed from A by DGGEV3.  On exit, S
          contains the Schur form matrix corresponding to the matrix
          in A.


T

          T is DOUBLE PRECISION array,
                                 dimension (LDA, max(NN))
          The upper triangular matrix computed from B by DGGEV3.


Q

          Q is DOUBLE PRECISION array,
                                 dimension (LDQ, max(NN))
          The (left) eigenvectors matrix computed by DGGEV3.


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 DOUBLE PRECISION array, dimension( LDQ, max(NN) )
          The (right) orthogonal matrix computed by DGGEV3.


QE

          QE is DOUBLE PRECISION 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)).


ALPHAR

          ALPHAR is DOUBLE PRECISION array, dimension (max(NN))


ALPHAI

          ALPHAI is DOUBLE PRECISION array, dimension (max(NN))


BETA

          BETA is DOUBLE PRECISION array, dimension (max(NN))
          The generalized eigenvalues of (A,B) computed by DGGEV3.
          ( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the k-th
          generalized eigenvalue of A and B.


ALPHR1

          ALPHR1 is DOUBLE PRECISION array, dimension (max(NN))


ALPHI1

          ALPHI1 is DOUBLE PRECISION array, dimension (max(NN))


BETA1

          BETA1 is DOUBLE PRECISION array, dimension (max(NN))
          Like ALPHAR, ALPHAI, BETA, these arrays contain the
          eigenvalues of A and B, but those computed when DGGEV3 only
          computes a partial eigendecomposition, i.e. not the
          eigenvalues and left and right eigenvectors.


WORK

          WORK is DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The number of entries in WORK.  LWORK >= MAX( 8*N, N*(N+1) ).


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:

February 2015

subroutine ddrgsx (integer NSIZE, integer NCMAX, double precision THRESH, integer NIN, integer NOUT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) AI, double precision, dimension( lda, * ) BI, double precision, dimension( lda, * ) Z, double precision, dimension( lda, * ) Q, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) S, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, logical, dimension( * ) BWORK, integer INFO)

DDRGSX

Purpose:

 DDRGSX checks the nonsymmetric generalized eigenvalue (Schur form)
 problem expert driver DGGESX.
 DGGESX factors A and B as Q S Z' and Q T Z', where ' means
 transpose, T is upper triangular, S is in generalized Schur form
 (block upper triangular, with 1x1 and 2x2 blocks on the diagonal,
 the 2x2 blocks corresponding to complex conjugate pairs of
 generalized eigenvalues), and Q and Z are orthogonal.  It also
 computes the generalized eigenvalues (alpha(1),beta(1)), ...,
 (alpha(n),beta(n)). Thus, w(j) = alpha(j)/beta(j) is a root of the
 characteristic equation
     det( A - w(j) B ) = 0
 Optionally it also reorders the eigenvalues so that a selected
 cluster of eigenvalues appears in the leading diagonal block of the
 Schur forms; computes a reciprocal condition number for the average
 of the selected eigenvalues; and computes a reciprocal condition
 number for the right and left deflating subspaces corresponding to
 the selected eigenvalues.
 When DDRGSX is called with NSIZE > 0, five (5) types of built-in
 matrix pairs are used to test the routine DGGESX.
 When DDRGSX is called with NSIZE = 0, it reads in test matrix data
 to test DGGESX.
 For each matrix pair, the following tests will be performed and
 compared with the threshold THRESH except for the tests (7) and (9):
 (1)   | A - Q S Z' | / ( |A| n ulp )
 (2)   | B - Q T Z' | / ( |B| n ulp )
 (3)   | I - QQ' | / ( n ulp )
 (4)   | I - ZZ' | / ( n ulp )
 (5)   if A is in Schur form (i.e. quasi-triangular form)
 (6)   maximum over j of D(j)  where:
       if alpha(j) is real:
                     |alpha(j) - S(j,j)|        |beta(j) - T(j,j)|
           D(j) = ------------------------ + -----------------------
                  max(|alpha(j)|,|S(j,j)|)   max(|beta(j)|,|T(j,j)|)
       if alpha(j) is complex:
                                 | det( s S - w T ) |
           D(j) = ---------------------------------------------------
                  ulp max( s norm(S), |w| norm(T) )*norm( s S - w T )
           and S and T are here the 2 x 2 diagonal blocks of S and T
           corresponding to the j-th and j+1-th eigenvalues.
 (7)   if sorting worked and SDIM is the number of eigenvalues
       which were selected.
 (8)   the estimated value DIF does not differ from the true values of
       Difu and Difl more than a factor 10*THRESH. If the estimate DIF
       equals zero the corresponding true values of Difu and Difl
       should be less than EPS*norm(A, B). If the true value of Difu
       and Difl equal zero, the estimate DIF should be less than
       EPS*norm(A, B).
 (9)   If INFO = N+3 is returned by DGGESX, the reordering "failed"
       and we check that DIF = PL = PR = 0 and that the true value of
       Difu and Difl is < EPS*norm(A, B). We count the events when
       INFO=N+3.
 For read-in test matrices, the above tests are run except that the
 exact value for DIF (and PL) is input data.  Additionally, there is
 one more test run for 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 DGESVD) 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 DLAKF2


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 IINFO not equal to 0.)


A

          A is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Used to store the matrix whose eigenvalues are to be
          computed.  On exit, A contains the last matrix actually used.


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 DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Used to store the matrix whose eigenvalues are to be
          computed.  On exit, B contains the last matrix actually used.


AI

          AI is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Copy of A, modified by DGGESX.


BI

          BI is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Copy of B, modified by DGGESX.


Z

          Z is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Z holds the left Schur vectors computed by DGGESX.


Q

          Q is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Q holds the right Schur vectors computed by DGGESX.


ALPHAR

          ALPHAR is DOUBLE PRECISION array, dimension (NSIZE)


ALPHAI

          ALPHAI is DOUBLE PRECISION array, dimension (NSIZE)


BETA

          BETA is DOUBLE PRECISION array, dimension (NSIZE)
          On exit, (ALPHAR + ALPHAI*i)/BETA are the eigenvalues.


C

          C is DOUBLE PRECISION array, dimension (LDC, LDC)
          Store the matrix generated by subroutine DLAKF2, this is the
          matrix formed by Kronecker products used for estimating
          DIF.


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 DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.
          LWORK >= MAX( 5*NSIZE*NSIZE/2 - 2, 10*(NSIZE+1) )


IWORK

          IWORK is INTEGER array, dimension (LIWORK)


LIWORK

          LIWORK is INTEGER
          The dimension of the array IWORK. LIWORK >= NSIZE + 6.


BWORK

          BWORK is LOGICAL array, dimension (LDA)


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 ddrgvx (integer NSIZE, double precision THRESH, integer NIN, integer NOUT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) B, double precision, dimension( lda, * ) AI, double precision, dimension( lda, * ) BI, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( lda, * ) VL, double precision, dimension( lda, * ) VR, integer ILO, integer IHI, double precision, dimension( * ) LSCALE, double precision, dimension( * ) RSCALE, double precision, dimension( * ) S, double precision, dimension( * ) DTRU, double precision, dimension( * ) DIF, double precision, dimension( * ) DIFTRU, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, double precision, dimension( 4 ) RESULT, logical, dimension( * ) BWORK, integer INFO)

DDRGVX

Purpose:

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


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 DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Used to hold the matrix whose eigenvalues are to be
          computed.  On exit, A contains the last matrix actually used.


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 DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Used to hold the matrix whose eigenvalues are to be
          computed.  On exit, B contains the last matrix actually used.


AI

          AI is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Copy of A, modified by DGGEVX.


BI

          BI is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          Copy of B, modified by DGGEVX.


ALPHAR

          ALPHAR is DOUBLE PRECISION array, dimension (NSIZE)


ALPHAI

          ALPHAI is DOUBLE PRECISION array, dimension (NSIZE)


BETA

          BETA is DOUBLE PRECISION array, dimension (NSIZE)
          On exit, (ALPHAR + ALPHAI*i)/BETA are the eigenvalues.


VL

          VL is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          VL holds the left eigenvectors computed by DGGEVX.


VR

          VR is DOUBLE PRECISION array, dimension (LDA, NSIZE)
          VR holds the right eigenvectors computed by DGGEVX.


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 DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          Leading dimension of WORK.  LWORK >= 2*N*N+12*N+16.


IWORK

          IWORK is INTEGER array, dimension (LIWORK)


LIWORK

          LIWORK is INTEGER
          Leading dimension of IWORK.  Must be at least N+6.


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:

April 2012

subroutine ddrvbd (integer NSIZES, integer, dimension( * ) MM, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldvt, * ) VT, integer LDVT, double precision, dimension( lda, * ) ASAV, double precision, dimension( ldu, * ) USAV, double precision, dimension( ldvt, * ) VTSAV, double precision, dimension( * ) S, double precision, dimension( * ) SSAV, double precision, dimension( * ) E, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer NOUT, integer INFO)

DDRVBD

Purpose:

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


 

Parameters:

NSIZES

          NSIZES is INTEGER
          The number of matrix sizes (M,N) contained in the vectors
          MM and NN.


MM

          MM is INTEGER array, dimension (NSIZES)
          The values of the matrix row dimension M.


NN

          NN is INTEGER array, dimension (NSIZES)
          The values of the matrix column dimension N.


NTYPES

          NTYPES is INTEGER
          The number of elements in DOTYPE.   If it is zero, DDRVBD
          does nothing.  It must be at least zero.  If it is MAXTYP+1
          and NSIZES is 1, then an additional type, MAXTYP+1 is
          defined, which is to use whatever matrices are in A and B.
          This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
          DOTYPE(MAXTYP+1) is .TRUE. .


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, the seed of the random number generator.  The array
          elements should be between 0 and 4095; if not they will be
          reduced mod 4096.  Also, ISEED(4) must be odd.
          On exit, ISEED is changed and can be used in the next call to
          DDRVBD to continue the same random number sequence.


THRESH

          THRESH is DOUBLE PRECISION
          The threshold value for the test ratios.  A result is
          included in the output file if RESULT >= THRESH.  The test
          ratios are scaled to be O(1), so THRESH should be a small
          multiple of 1, e.g., 10 or 100.  To have every test ratio
          printed, use THRESH = 0.


A

          A is DOUBLE PRECISION array, dimension (LDA,NMAX)
          where NMAX is the maximum value of N in NN.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,MMAX),
          where MMAX is the maximum value of M in MM.


U

          U is DOUBLE PRECISION array, dimension (LDU,MMAX)


LDU

          LDU is INTEGER
          The leading dimension of the array U.  LDU >= max(1,MMAX).


VT

          VT is DOUBLE PRECISION array, dimension (LDVT,NMAX)


LDVT

          LDVT is INTEGER
          The leading dimension of the array VT.  LDVT >= max(1,NMAX).


ASAV

          ASAV is DOUBLE PRECISION array, dimension (LDA,NMAX)


USAV

          USAV is DOUBLE PRECISION array, dimension (LDU,MMAX)


VTSAV

          VTSAV is DOUBLE PRECISION array, dimension (LDVT,NMAX)


S

          S is DOUBLE PRECISION array, dimension
                      (max(min(MM,NN)))


SSAV

          SSAV is DOUBLE PRECISION array, dimension
                      (max(min(MM,NN)))


E

          E is DOUBLE PRECISION array, dimension
                      (max(min(MM,NN)))


WORK

          WORK is DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The number of entries in WORK.  This must be at least
          max(3*MN+MX,5*MN-4)+2*MN**2 for all pairs
          pairs  (MN,MX)=( min(MM(j),NN(j), max(MM(j),NN(j)) )


IWORK

          IWORK is INTEGER array, dimension at least 8*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
           -7: THRESH < 0
          -10: LDA < 1 or LDA < MMAX, where MMAX is max( MM(j) ).
          -12: LDU < 1 or LDU < MMAX.
          -14: LDVT < 1 or LDVT < NMAX, where NMAX is max( NN(j) ).
          -21: LWORK too small.
          If  DLATMS, or DGESVD returns an error code, the
              absolute value of it is returned.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

June 2016

subroutine ddrves (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( lda, * ) HT, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WRT, double precision, dimension( * ) WIT, double precision, dimension( ldvs, * ) VS, integer LDVS, double precision, dimension( 13 ) RESULT, double precision, dimension( * ) WORK, integer NWORK, integer, dimension( * ) IWORK, logical, dimension( * ) BWORK, integer INFO)

DDRVES

Purpose:

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


 

Parameters:

NSIZES

          NSIZES is INTEGER
          The number of sizes of matrices to use.  If it is zero,
          DDRVES does nothing.  It must be at least zero.


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, DDRVES
          does nothing.  It must be at least zero.  If it is MAXTYP+1
          and NSIZES is 1, then an additional type, MAXTYP+1 is
          defined, which is to use whatever matrix is in A.  This
          is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
          DOTYPE(MAXTYP+1) is .TRUE. .


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 DDRVES 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 DOUBLE PRECISION array, dimension (LDA, max(NN))
          Used to hold the matrix whose eigenvalues are to be
          computed.  On exit, A contains the last matrix actually used.


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 DOUBLE PRECISION array, dimension (LDA, max(NN))
          Another copy of the test matrix A, modified by DGEES.


HT

          HT is DOUBLE PRECISION array, dimension (LDA, max(NN))
          Yet another copy of the test matrix A, modified by DGEES.


WR

          WR is DOUBLE PRECISION array, dimension (max(NN))


WI

          WI is DOUBLE PRECISION array, dimension (max(NN))
          The real and imaginary parts of the eigenvalues of A.
          On exit, WR + WI*i are the eigenvalues of the matrix in A.


WRT

          WRT is DOUBLE PRECISION array, dimension (max(NN))


WIT

          WIT is DOUBLE PRECISION array, dimension (max(NN))
          Like WR, WI, these arrays contain the eigenvalues of A,
          but those computed when DGEES only computes a partial
          eigendecomposition, i.e. not Schur vectors


VS

          VS is DOUBLE PRECISION 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 DOUBLE PRECISION 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.


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) ).
          -17: LDVS < 1 or LDVS < NMAX, where NMAX is max( NN(j) ).
          -20: NWORK too small.
          If  DLATMR, SLATMS, SLATME or DGEES returns an error code,
              the absolute value of it is returned.
-----------------------------------------------------------------------
     Some Local Variables and Parameters:
     ---- ----- --------- --- ----------
     ZERO, ONE       Real 0 and 1.
     MAXTYP          The number of types defined.
     NMAX            Largest value in NN.
     NERRS           The number of tests which have exceeded THRESH
     COND, CONDS,
     IMODE           Values to be passed to the matrix generators.
     ANORM           Norm of A; passed to matrix generators.
     OVFL, UNFL      Overflow and underflow thresholds.
     ULP, ULPINV     Finest relative precision and its inverse.
     RTULP, RTULPI   Square roots of the previous 4 values.
             The following four arrays decode JTYPE:
     KTYPE(j)        The general type (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 ddrvev (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WR1, double precision, dimension( * ) WI1, double precision, dimension( ldvl, * ) VL, integer LDVL, double precision, dimension( ldvr, * ) VR, integer LDVR, double precision, dimension( ldlre, * ) LRE, integer LDLRE, double precision, dimension( 7 ) RESULT, double precision, dimension( * ) WORK, integer NWORK, integer, dimension( * ) IWORK, integer INFO)

DDRVEV

Purpose:

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


 

Parameters:

NSIZES

          NSIZES is INTEGER
          The number of sizes of matrices to use.  If it is zero,
          DDRVEV does nothing.  It must be at least zero.


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, DDRVEV
          does nothing.  It must be at least zero.  If it is MAXTYP+1
          and NSIZES is 1, then an additional type, MAXTYP+1 is
          defined, which is to use whatever matrix is in A.  This
          is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
          DOTYPE(MAXTYP+1) is .TRUE. .


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 DDRVEV 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 DOUBLE PRECISION array, dimension (LDA, max(NN))
          Used to hold the matrix whose eigenvalues are to be
          computed.  On exit, A contains the last matrix actually used.


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 DOUBLE PRECISION array, dimension (LDA, max(NN))
          Another copy of the test matrix A, modified by DGEEV.


WR

          WR is DOUBLE PRECISION array, dimension (max(NN))


WI

          WI is DOUBLE PRECISION array, dimension (max(NN))
          The real and imaginary parts of the eigenvalues of A.
          On exit, WR + WI*i are the eigenvalues of the matrix in A.


WR1

          WR1 is DOUBLE PRECISION array, dimension (max(NN))


WI1

          WI1 is DOUBLE PRECISION array, dimension (max(NN))
          Like WR, WI, these arrays contain the eigenvalues of A,
          but those computed when DGEEV only computes a partial
          eigendecomposition, i.e. not the eigenvalues and left
          and right eigenvectors.


VL

          VL is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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.


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) ).
          -16: LDVL < 1 or LDVL < NMAX, where NMAX is max( NN(j) ).
          -18: LDVR < 1 or LDVR < NMAX, where NMAX is max( NN(j) ).
          -20: LDLRE < 1 or LDLRE < NMAX, where NMAX is max( NN(j) ).
          -23: NWORK too small.
          If  DLATMR, SLATMS, SLATME or DGEEV returns an error code,
              the absolute value of it is returned.
-----------------------------------------------------------------------
     Some Local Variables and Parameters:
     ---- ----- --------- --- ----------
     ZERO, ONE       Real 0 and 1.
     MAXTYP          The number of types defined.
     NMAX            Largest value in NN.
     NERRS           The number of tests which have exceeded THRESH
     COND, CONDS,
     IMODE           Values to be passed to the matrix generators.
     ANORM           Norm of A; passed to matrix generators.
     OVFL, UNFL      Overflow and underflow thresholds.
     ULP, ULPINV     Finest relative precision and its inverse.
     RTULP, RTULPI   Square roots of the previous 4 values.
             The following four arrays decode JTYPE:
     KTYPE(j)        The general type (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 ddrvsg (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) D, double precision, dimension( ldz, * ) Z, integer LDZ, double precision, dimension( lda, * ) AB, double precision, dimension( ldb, * ) BB, double precision, dimension( * ) AP, double precision, dimension( * ) BP, double precision, dimension( * ) WORK, integer NWORK, integer, dimension( * ) IWORK, integer LIWORK, double precision, dimension( * ) RESULT, integer INFO)

DDRVSG

Purpose:

      DDRVSG checks the real symmetric generalized eigenproblem
      drivers.
              DSYGV computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric-definite generalized
              eigenproblem.
              DSYGVD computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric-definite generalized
              eigenproblem using a divide and conquer algorithm.
              DSYGVX computes selected eigenvalues and, optionally,
              eigenvectors of a real symmetric-definite generalized
              eigenproblem.
              DSPGV computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric-definite generalized
              eigenproblem in packed storage.
              DSPGVD computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric-definite generalized
              eigenproblem in packed storage using a divide and
              conquer algorithm.
              DSPGVX computes selected eigenvalues and, optionally,
              eigenvectors of a real symmetric-definite generalized
              eigenproblem in packed storage.
              DSBGV computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric-definite banded
              generalized eigenproblem.
              DSBGVD computes all eigenvalues and, optionally,
              eigenvectors of a real symmetric-definite banded
              generalized eigenproblem using a divide and conquer
              algorithm.
              DSBGVX computes selected eigenvalues and, optionally,
              eigenvectors of a real symmetric-definite banded
              generalized eigenproblem.
      When DDRVSG is called, a number of matrix "sizes" ("n's") and a
      number of matrix "types" are specified.  For each size ("n")
      and each type of matrix, one matrix A of the given type will be
      generated; a random 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) DSYGV with ITYPE = 1 and UPLO ='U':
              | A Z - B Z D | / ( |A| |Z| n ulp )
      (2) as (1) but calling DSPGV
      (3) as (1) but calling DSBGV
      (4) as (1) but with UPLO = 'L'
      (5) as (4) but calling DSPGV
      (6) as (4) but calling DSBGV
      (7) DSYGV with ITYPE = 2 and UPLO ='U':
              | A B Z - Z D | / ( |A| |Z| n ulp )
      (8) as (7) but calling DSPGV
      (9) as (7) but with UPLO = 'L'
      (10) as (9) but calling DSPGV
      (11) DSYGV with ITYPE = 3 and UPLO ='U':
              | B A Z - Z D | / ( |A| |Z| n ulp )
      (12) as (11) but calling DSPGV
      (13) as (11) but with UPLO = 'L'
      (14) as (13) but calling DSPGV
      DSYGVD, DSPGVD and DSBGVD performed the same 14 tests.
      DSYGVX, DSPGVX and DSBGVX performed the above 14 tests with
      the parameter RANGE = 'A', 'N' and 'I', respectively.
      The "sizes" are specified by an array NN(1:NSIZES); the value
      of each element NN(j) specifies one size.
      The "types" are specified by a logical array DOTYPE( 1:NTYPES );
      if DOTYPE(j) is .TRUE., then matrix type "j" will be generated.
      This type is used for the matrix A which has 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 orthogonal and
           D has evenly spaced entries 1, ..., ULP with random signs
           on the diagonal.
      (9)  A matrix of the form  U* D U, where U is orthogonal and
           D has geometrically spaced entries 1, ..., ULP with random
           signs on the diagonal.
      (10) A matrix of the form  U* D U, where U is orthogonal and
           D has "clustered" entries 1, ULP,..., ULP with random
           signs on the diagonal.
      (11) Same as (8), but multiplied by SQRT( overflow threshold )
      (12) Same as (8), but multiplied by SQRT( underflow threshold )
      (13) symmetric matrix with random entries chosen from (-1,1).
      (14) Same as (13), but multiplied by SQRT( overflow threshold )
      (15) Same as (13), but multiplied by SQRT( underflow threshold)
      (16) Same as (8), but with KA = 1 and KB = 1
      (17) Same as (8), but with KA = 2 and KB = 1
      (18) Same as (8), but with KA = 2 and KB = 2
      (19) Same as (8), but with KA = 3 and KB = 1
      (20) Same as (8), but with KA = 3 and KB = 2
      (21) Same as (8), but with KA = 3 and KB = 3


 

  NSIZES  INTEGER
          The number of sizes of matrices to use.  If it is zero,
          DDRVSG does nothing.  It must be at least zero.
          Not modified.
  NN      INTEGER array, dimension (NSIZES)
          An array containing the sizes to be used for the matrices.
          Zero values will be skipped.  The values must be at least
          zero.
          Not modified.
  NTYPES  INTEGER
          The number of elements in DOTYPE.   If it is zero, DDRVSG
          does nothing.  It must be at least zero.  If it is MAXTYP+1
          and NSIZES is 1, then an additional type, MAXTYP+1 is
          defined, which is to use whatever matrix is in A.  This
          is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
          DOTYPE(MAXTYP+1) is .TRUE. .
          Not modified.
  DOTYPE  LOGICAL array, dimension (NTYPES)
          If DOTYPE(j) is .TRUE., then for each size in NN a
          matrix of that size and of type j will be generated.
          If NTYPES is smaller than the maximum number of types
          defined (PARAMETER MAXTYP), then types NTYPES+1 through
          MAXTYP will not be generated.  If NTYPES is larger
          than MAXTYP, DOTYPE(MAXTYP+1) through DOTYPE(NTYPES)
          will be ignored.
          Not modified.
  ISEED   INTEGER array, dimension (4)
          On entry ISEED specifies the seed of the random number
          generator. The array elements should be between 0 and 4095;
          if not they will be reduced mod 4096.  Also, ISEED(4) must
          be odd.  The random number generator uses a linear
          congruential sequence limited to small integers, and so
          should produce machine independent random numbers. The
          values of ISEED are changed on exit, and can be used in the
          next call to DDRVSG to continue the same random number
          sequence.
          Modified.
  THRESH  DOUBLE PRECISION
          A test will count as "failed" if the "error", computed as
          described above, exceeds THRESH.  Note that the error
          is scaled to be O(1), so THRESH should be a reasonably
          small multiple of 1, e.g., 10 or 100.  In particular,
          it should not depend on the precision (single vs. double)
          or the size of the matrix.  It must be at least zero.
          Not modified.
  NOUNIT  INTEGER
          The FORTRAN unit number for printing out error messages
          (e.g., if a routine returns IINFO not equal to 0.)
          Not modified.
  A       DOUBLE PRECISION array, dimension (LDA , max(NN))
          Used to hold the matrix whose eigenvalues are to be
          computed.  On exit, A contains the last matrix actually
          used.
          Modified.
  LDA     INTEGER
          The leading dimension of A and AB.  It must be at
          least 1 and at least max( NN ).
          Not modified.
  B       DOUBLE PRECISION array, dimension (LDB , max(NN))
          Used to hold the symmetric positive definite matrix for
          the generailzed problem.
          On exit, B contains the last matrix actually
          used.
          Modified.
  LDB     INTEGER
          The leading dimension of B and BB.  It must be at
          least 1 and at least max( NN ).
          Not modified.
  D       DOUBLE PRECISION array, dimension (max(NN))
          The eigenvalues of A. On exit, the eigenvalues in D
          correspond with the matrix in A.
          Modified.
  Z       DOUBLE PRECISION array, dimension (LDZ, max(NN))
          The matrix of eigenvectors.
          Modified.
  LDZ     INTEGER
          The leading dimension of Z.  It must be at least 1 and
          at least max( NN ).
          Not modified.
  AB      DOUBLE PRECISION array, dimension (LDA, max(NN))
          Workspace.
          Modified.
  BB      DOUBLE PRECISION array, dimension (LDB, max(NN))
          Workspace.
          Modified.
  AP      DOUBLE PRECISION array, dimension (max(NN)**2)
          Workspace.
          Modified.
  BP      DOUBLE PRECISION array, dimension (max(NN)**2)
          Workspace.
          Modified.
  WORK    DOUBLE PRECISION array, dimension (NWORK)
          Workspace.
          Modified.
  NWORK   INTEGER
          The number of entries in WORK.  This must be at least
          1+5*N+2*N*lg(N)+3*N**2 where N = max( NN(j) ) and
          lg( N ) = smallest integer k such that 2**k >= N.
          Not modified.
  IWORK   INTEGER array, dimension (LIWORK)
          Workspace.
          Modified.
  LIWORK  INTEGER
          The number of entries in WORK.  This must be at least 6*N.
          Not modified.
  RESULT  DOUBLE PRECISION array, dimension (70)
          The values computed by the 70 tests described above.
          Modified.
  INFO    INTEGER
          If 0, then everything ran OK.
           -1: NSIZES < 0
           -2: Some NN(j) < 0
           -3: NTYPES < 0
           -5: THRESH < 0
           -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).
          -16: LDZ < 1 or LDZ < NMAX.
          -21: NWORK too small.
          -23: LIWORK too small.
          If  DLATMR, SLATMS, DSYGV, DSPGV, DSBGV, SSYGVD, SSPGVD,
              DSBGVD, DSYGVX, DSPGVX or SSBGVX returns an error code,
              the absolute value of it is returned.
          Modified.
 ----------------------------------------------------------------------
       Some Local Variables and Parameters:
       ---- ----- --------- --- ----------
       ZERO, ONE       Real 0 and 1.
       MAXTYP          The number of types defined.
       NTEST           The number of tests that have been run
                       on this matrix.
       NTESTT          The total number of tests for this call.
       NMAX            Largest value in NN.
       NMATS           The number of matrices generated so far.
       NERRS           The number of tests which have exceeded THRESH
                       so far (computed by DLAFTS).
       COND, IMODE     Values to be passed to the matrix generators.
       ANORM           Norm of A; passed to matrix generators.
       OVFL, UNFL      Overflow and underflow thresholds.
       ULP, ULPINV     Finest relative precision and its inverse.
       RTOVFL, RTUNFL  Square roots of the previous 2 values.
               The following four arrays decode JTYPE:
       KTYPE(j)        The general type (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 ddrvst (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D1, double precision, dimension( * ) D2, double precision, dimension( * ) D3, double precision, dimension( * ) D4, double precision, dimension( * ) EVEIGS, double precision, dimension( * ) WA1, double precision, dimension( * ) WA2, double precision, dimension( * ) WA3, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldu, * ) V, double precision, dimension( * ) TAU, double precision, dimension( ldu, * ) Z, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer LIWORK, double precision, dimension( * ) RESULT, integer INFO)

DDRVST

Purpose:

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


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ddrvsx (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NIUNIT, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( lda, * ) HT, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WRT, double precision, dimension( * ) WIT, double precision, dimension( * ) WRTMP, double precision, dimension( * ) WITMP, double precision, dimension( ldvs, * ) VS, integer LDVS, double precision, dimension( ldvs, * ) VS1, double precision, dimension( 17 ) RESULT, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, logical, dimension( * ) BWORK, integer INFO)

DDRVSX

Purpose:

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


 

Parameters:

NSIZES

          NSIZES is INTEGER
          The number of sizes of matrices to use.  NSIZES must be at
          least zero. If it is zero, no randomly generated matrices
          are tested, but any test matrices read from NIUNIT will be
          tested.


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 DDRVSX 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 DOUBLE PRECISION array, dimension (LDA, max(NN))
          Used to hold the matrix whose eigenvalues are to be
          computed.  On exit, A contains the last matrix actually used.


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 DOUBLE PRECISION array, dimension (LDA, max(NN))
          Another copy of the test matrix A, modified by DGEESX.


HT

          HT is DOUBLE PRECISION array, dimension (LDA, max(NN))
          Yet another copy of the test matrix A, modified by DGEESX.


WR

          WR is DOUBLE PRECISION array, dimension (max(NN))


WI

          WI is DOUBLE PRECISION array, dimension (max(NN))
          The real and imaginary parts of the eigenvalues of A.
          On exit, WR + WI*i are the eigenvalues of the matrix in A.


WRT

          WRT is DOUBLE PRECISION array, dimension (max(NN))


WIT

          WIT is DOUBLE PRECISION array, dimension (max(NN))
          Like WR, WI, these arrays contain the eigenvalues of A,
          but those computed when DGEESX only computes a partial
          eigendecomposition, i.e. not Schur vectors


WRTMP

          WRTMP is DOUBLE PRECISION array, dimension (max(NN))


WITMP

          WITMP is DOUBLE PRECISION array, dimension (max(NN))
          More temporary storage for eigenvalues.


VS

          VS is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The number of entries in WORK.  This must be at least
          max(3*NN(j),2*NN(j)**2) for all j.


IWORK

          IWORK is INTEGER array, dimension (max(NN)*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,  DLATMR, SLATMS, SLATME or DGET24 returned an error
                 code and INFO is its absolute value
-----------------------------------------------------------------------
     Some Local Variables and Parameters:
     ---- ----- --------- --- ----------
     ZERO, ONE       Real 0 and 1.
     MAXTYP          The number of types defined.
     NMAX            Largest value in NN.
     NERRS           The number of tests which have exceeded THRESH
     COND, CONDS,
     IMODE           Values to be passed to the matrix generators.
     ANORM           Norm of A; passed to matrix generators.
     OVFL, UNFL      Overflow and underflow thresholds.
     ULP, ULPINV     Finest relative precision and its inverse.
     RTULP, RTULPI   Square roots of the previous 4 values.
             The following four arrays decode JTYPE:
     KTYPE(j)        The general type (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 ddrvvx (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer NIUNIT, integer NOUNIT, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WR1, double precision, dimension( * ) WI1, double precision, dimension( ldvl, * ) VL, integer LDVL, double precision, dimension( ldvr, * ) VR, integer LDVR, double precision, dimension( ldlre, * ) LRE, integer LDLRE, double precision, dimension( * ) RCONDV, double precision, dimension( * ) RCNDV1, double precision, dimension( * ) RCDVIN, double precision, dimension( * ) RCONDE, double precision, dimension( * ) RCNDE1, double precision, dimension( * ) RCDEIN, double precision, dimension( * ) SCALE, double precision, dimension( * ) SCALE1, double precision, dimension( 11 ) RESULT, double precision, dimension( * ) WORK, integer NWORK, integer, dimension( * ) IWORK, integer INFO)

DDRVVX

Purpose:

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


 

Parameters:

NSIZES

          NSIZES is INTEGER
          The number of sizes of matrices to use.  NSIZES must be at
          least zero. If it is zero, no randomly generated matrices
          are tested, but any test matrices read from NIUNIT will be
          tested.


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 DDRVVX 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 DOUBLE PRECISION array, dimension
                      (LDA, max(NN,12))
          Used to hold the matrix whose eigenvalues are to be
          computed.  On exit, A contains the last matrix actually used.


LDA

          LDA is INTEGER
          The leading dimension of the arrays A and H.
          LDA >= max(NN,12), since 12 is the dimension of the largest
          matrix in the precomputed input file.


H

          H is DOUBLE PRECISION array, dimension
                      (LDA, max(NN,12))
          Another copy of the test matrix A, modified by DGEEVX.


WR

          WR is DOUBLE PRECISION array, dimension (max(NN))


WI

          WI is DOUBLE PRECISION array, dimension (max(NN))
          The real and imaginary parts of the eigenvalues of A.
          On exit, WR + WI*i are the eigenvalues of the matrix in A.


WR1

          WR1 is DOUBLE PRECISION array, dimension (max(NN,12))


WI1

          WI1 is DOUBLE PRECISION array, dimension (max(NN,12))
          Like WR, WI, these arrays contain the eigenvalues of A,
          but those computed when DGEEVX only computes a partial
          eigendecomposition, i.e. not the eigenvalues and left
          and right eigenvectors.


VL

          VL is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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.


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.


WORK

          WORK is DOUBLE PRECISION array, dimension (NWORK)


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.


IWORK

          IWORK is INTEGER 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, DLATMR, SLATMS, SLATME or DGET23 returned an error
                 code, and INFO is its absolute value.
-----------------------------------------------------------------------
     Some Local Variables and Parameters:
     ---- ----- --------- --- ----------
     ZERO, ONE       Real 0 and 1.
     MAXTYP          The number of types defined.
     NMAX            Largest value in NN or 12.
     NERRS           The number of tests which have exceeded THRESH
     COND, CONDS,
     IMODE           Values to be passed to the matrix generators.
     ANORM           Norm of A; passed to matrix generators.
     OVFL, UNFL      Overflow and underflow thresholds.
     ULP, ULPINV     Finest relative precision and its inverse.
     RTULP, RTULPI   Square roots of the previous 4 values.
             The following four arrays decode JTYPE:
     KTYPE(j)        The general type (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 derrbd (character*3 PATH, integer NUNIT)

DERRBD

Purpose:

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


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


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 derrec (character*3 PATH, integer NUNIT)

DERREC

Purpose:

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


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


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 derred (character*3 PATH, integer NUNIT)

DERRED

Purpose:

 DERRED tests the error exits for the eigenvalue driver routines for
 DOUBLE PRECISION matrices:
 PATH  driver   description
 ----  ------   -----------
 SEV   DGEEV    find eigenvalues/eigenvectors for nonsymmetric A
 SES   DGEES    find eigenvalues/Schur form for nonsymmetric A
 SVX   DGEEVX   SGEEV + balancing and condition estimation
 SSX   DGEESX   SGEES + balancing and condition estimation
 DBD   DGESVD   compute SVD of an M-by-N matrix A
       DGESDD   compute SVD of an M-by-N matrix A (by divide and
                conquer)
       DGEJSV   compute SVD of an M-by-N matrix A where M >= N
       DGESVDX  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 derrgg (character*3 PATH, integer NUNIT)

DERRGG

Purpose:

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


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


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 derrhs (character*3 PATH, integer NUNIT)

DERRHS

Purpose:

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


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


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 derrst (character*3 PATH, integer NUNIT)

DERRST

Purpose:

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


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


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 dget02 (character TRANS, integer M, integer N, integer NRHS, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldx, * ) X, integer LDX, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)

DGET02

Purpose:

 DGET02 computes the residual for a solution of a system of linear
 equations  A*x = b  or  A'*x = b:
    RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

TRANS

          TRANS is CHARACTER*1
          Specifies the form of the system of equations:
          = 'N':  A *x = b
          = 'T':  A'*x = b, where A' is the transpose of A
          = 'C':  A'*x = b, where A' is the transpose of A


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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - A*X.


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 dget10 (integer M, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) WORK, double precision RESULT)

DGET10

Purpose:

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


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrices A and B.


N

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


A

          A is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 dget22 (character TRANSA, character TRANSE, character TRANSW, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lde, * ) E, integer LDE, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)

DGET22

Purpose:

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


 

Parameters:

TRANSA

          TRANSA is CHARACTER*1
          Specifies whether or not A is transposed.
          = 'N':  No transpose
          = 'T':  Transpose
          = 'C':  Conjugate transpose (= Transpose)


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 (= Transpose)


TRANSW

          TRANSW is CHARACTER*1
          Specifies whether or not W is transposed.
          = 'N':  No transpose
          = 'T':  Transpose, use -WI(j) instead of WI(j)
          = 'C':  Conjugate transpose, use -WI(j) instead of WI(j)


N

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


A

          A is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDE,N)
          The matrix of eigenvectors. If TRANSE = 'N', the eigenvectors
          are stored in the columns of E, if TRANSE = 'T' or 'C', the
          eigenvectors are stored in the rows of E.


LDE

          LDE is INTEGER
          The leading dimension of the array E.  LDE >= max(1,N).


WR

          WR is DOUBLE PRECISION array, dimension (N)


WI

          WI is DOUBLE PRECISION array, dimension (N)
          The real and imaginary parts of the eigenvalues of A.
          Purely real eigenvalues are indicated by WI(j) = 0.
          Complex conjugate pairs are indicated by WR(j)=WR(j+1) and
          WI(j) = - WI(j+1) non-zero; the real part is assumed to be
          stored in the j-th row/column and the imaginary part in
          the (j+1)-th row/column.


WORK

          WORK is DOUBLE PRECISION array, dimension (N*(N+1))


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 dget23 (logical COMP, character BALANC, integer JTYPE, double precision THRESH, integer, dimension( 4 ) ISEED, integer NOUNIT, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WR1, double precision, dimension( * ) WI1, double precision, dimension( ldvl, * ) VL, integer LDVL, double precision, dimension( ldvr, * ) VR, integer LDVR, double precision, dimension( ldlre, * ) LRE, integer LDLRE, double precision, dimension( * ) RCONDV, double precision, dimension( * ) RCNDV1, double precision, dimension( * ) RCDVIN, double precision, dimension( * ) RCONDE, double precision, dimension( * ) RCNDE1, double precision, dimension( * ) RCDEIN, double precision, dimension( * ) SCALE, double precision, dimension( * ) SCALE1, double precision, dimension( 11 ) RESULT, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer INFO)

DGET23

Purpose:

    DGET23  checks the nonsymmetric eigenvalue problem driver SGEEVX.
    If COMP = .FALSE., the first 8 of the following tests will be
    performed on the input matrix A, and also test 9 if LWORK is
    sufficiently large.
    if COMP is .TRUE. all 11 tests will be performed.
    (1)     | A * VR - VR * W | / ( n |A| ulp )
      Here VR is the matrix of unit right eigenvectors.
      W is a block diagonal matrix, with a 1x1 block for each
      real eigenvalue and a 2x2 block for each complex conjugate
      pair.  If eigenvalues j and j+1 are a complex conjugate pair,
      so WR(j) = WR(j+1) = wr and WI(j) = - WI(j+1) = wi, then the
      2 x 2 block corresponding to the pair will be:
              (  wr  wi  )
              ( -wi  wr  )
      Such a block multiplying an n x 2 matrix  ( ur ui ) on the
      right will be the same as multiplying  ur + i*ui  by  wr + i*wi.
    (2)     | A**H * VL - VL * W**H | / ( n |A| ulp )
      Here VL is the matrix of unit left eigenvectors, A**H is the
      conjugate transpose of A, and W is as above.
    (3)     | |VR(i)| - 1 | / ulp and largest component real
      VR(i) denotes the 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 DGEEVX and RCDVIN (the precomputed true value)
      is supplied as input. cond(RCONDV) is the condition number of
      RCONDV, and takes errors in computing RCONDV into account, so
      that the resulting quantity should be O(ULP). cond(RCONDV) is
      essentially given by norm(A)/RCONDE.
   (11)     |RCONDE - RCDEIN| / cond(RCONDE)
      RCONDE is the reciprocal eigenvalue condition number
      computed by DGEEVX and RCDEIN (the precomputed true value)
      is supplied as input.  cond(RCONDE) is the condition number
      of RCONDE, and takes errors in computing RCONDE into account,
      so that the resulting quantity should be O(ULP). cond(RCONDE)
      is essentially given by norm(A)/RCONDV.


 

Parameters:

COMP

          COMP is LOGICAL
          COMP describes which input tests to perform:
            = .FALSE. if the computed condition numbers are not to
                      be tested against RCDVIN and RCDEIN
            = .TRUE.  if they are to be compared


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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDA,N)
          Another copy of the test matrix A, modified by DGEEVX.


WR

          WR is DOUBLE PRECISION array, dimension (N)


WI

          WI is DOUBLE PRECISION array, dimension (N)
          The real and imaginary parts of the eigenvalues of A.
          On exit, WR + WI*i are the eigenvalues of the matrix in A.


WR1

          WR1 is DOUBLE PRECISION array, dimension (N)


WI1

          WI1 is DOUBLE PRECISION array, dimension (N)
          Like WR, WI, these arrays contain the eigenvalues of A,
          but those computed when DGEEVX only computes a partial
          eigendecomposition, i.e. not the eigenvalues and left
          and right eigenvectors.


VL

          VL is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The number of entries in WORK.  This must be at least
          3*N, and 6*N+N**2 if tests 9, 10 or 11 are to be performed.


IWORK

          IWORK is INTEGER array, dimension (2*N)


INFO

          INFO is INTEGER
          If 0,  successful exit.
          If <0, input parameter -INFO had an incorrect value.
          If >0, DGEEVX returned an error code, the absolute
                 value of which is returned.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dget24 (logical COMP, integer JTYPE, double precision THRESH, integer, dimension( 4 ) ISEED, integer NOUNIT, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( lda, * ) H, double precision, dimension( lda, * ) HT, double precision, dimension( * ) WR, double precision, dimension( * ) WI, double precision, dimension( * ) WRT, double precision, dimension( * ) WIT, double precision, dimension( * ) WRTMP, double precision, dimension( * ) WITMP, double precision, dimension( ldvs, * ) VS, integer LDVS, double precision, dimension( ldvs, * ) VS1, double precision RCDEIN, double precision RCDVIN, integer NSLCT, integer, dimension( * ) ISLCT, double precision, dimension( 17 ) RESULT, double precision, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, logical, dimension( * ) BWORK, integer INFO)

DGET24

Purpose:

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


 

Parameters:

COMP

          COMP is LOGICAL
          COMP describes which input tests to perform:
            = .FALSE. if the computed condition numbers are not to
                      be tested against RCDVIN and RCDEIN
            = .TRUE.  if they are to be compared


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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDA, N)
          Another copy of the test matrix A, modified by DGEESX.


HT

          HT is DOUBLE PRECISION array, dimension (LDA, N)
          Yet another copy of the test matrix A, modified by DGEESX.


WR

          WR is DOUBLE PRECISION array, dimension (N)


WI

          WI is DOUBLE PRECISION array, dimension (N)
          The real and imaginary parts of the eigenvalues of A.
          On exit, WR + WI*i are the eigenvalues of the matrix in A.


WRT

          WRT is DOUBLE PRECISION array, dimension (N)


WIT

          WIT is DOUBLE PRECISION array, dimension (N)
          Like WR, WI, these arrays contain the eigenvalues of A,
          but those computed when DGEESX only computes a partial
          eigendecomposition, i.e. not Schur vectors


WRTMP

          WRTMP is DOUBLE PRECISION array, dimension (N)


WITMP

          WITMP is DOUBLE PRECISION array, dimension (N)
          Like WR, WI, these arrays contain the eigenvalues of A,
          but sorted by increasing real part.


VS

          VS is DOUBLE PRECISION 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 DOUBLE PRECISION 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 part is selected.
          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 DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The number of entries in WORK to be passed to DGEESX. This
          must be at least 3*N, and N+N**2 if tests 14--16 are to
          be performed.


IWORK

          IWORK is INTEGER array, dimension (N*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, DGEESX returned an error code, the absolute
                 value of which is returned.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dget31 (double precision RMAX, integer LMAX, integer, dimension( 2 ) NINFO, integer KNT)

DGET31

Purpose:

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


KNT

          KNT is INTEGER
          Total number of examples tested.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dget32 (double precision RMAX, integer LMAX, integer NINFO, integer KNT)

DGET32

Purpose:

 DGET32 tests DLASY2, a routine for solving
         op(TL)*X + ISGN*X*op(TR) = SCALE*B
 where TL is N1 by N1, TR is N2 by N2, and N1,N2 =1 or 2 only.
 X and B are N1 by N2, op() is an optional transpose, an
 ISGN = 1 or -1. SCALE is chosen less than or equal to 1 to
 avoid overflow in X.
 The test condition is that the scaled residual
 norm( op(TL)*X + ISGN*X*op(TR) = SCALE*B )
      / ( max( ulp*norm(TL), ulp*norm(TR)) * norm(X), SMLNUM )
 should be on the order of 1. Here, ulp is the machine precision.
 Also, it is verified that SCALE is less than or equal to 1, and
 that XNORM = infinity-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 returned with INFO.NE.0.


KNT

          KNT is INTEGER
          Total number of examples tested.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dget33 (double precision RMAX, integer LMAX, integer NINFO, integer KNT)

DGET33

Purpose:

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


 

Parameters:

RMAX

          RMAX is DOUBLE PRECISION
          Value of the largest test ratio.


LMAX

          LMAX is INTEGER
          Example number where largest test ratio achieved.


NINFO

          NINFO is INTEGER
          Number of examples returned with INFO .NE. 0.


KNT

          KNT is INTEGER
          Total number of examples tested.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dget34 (double precision RMAX, integer LMAX, integer, dimension( 2 ) NINFO, integer KNT)

DGET34

Purpose:

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


 

Parameters:

RMAX

          RMAX is DOUBLE PRECISION
          Value of the largest test ratio.


LMAX

          LMAX is INTEGER
          Example number where largest test ratio achieved.


NINFO

          NINFO is INTEGER array, dimension (2)
          NINFO(J) is the number of examples where INFO=J occurred.


KNT

          KNT is INTEGER
          Total number of examples tested.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dget35 (double precision RMAX, integer LMAX, integer NINFO, integer KNT)

DGET35

Purpose:

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


 

Parameters:

RMAX

          RMAX is DOUBLE PRECISION
          Value of the largest test ratio.


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.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dget36 (double precision RMAX, integer LMAX, integer, dimension( 3 ) NINFO, integer KNT, integer NIN)

DGET36

Purpose:

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


 

Parameters:

RMAX

          RMAX is DOUBLE PRECISION
          Value of the largest test ratio.


LMAX

          LMAX is INTEGER
          Example number where largest test ratio achieved.


NINFO

          NINFO is INTEGER array, dimension (3)
          NINFO(J) is the number of examples where INFO=J.


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 dget37 (double precision, dimension( 3 ) RMAX, integer, dimension( 3 ) LMAX, integer, dimension( 3 ) NINFO, integer KNT, integer NIN)

DGET37

Purpose:

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


 

Parameters:

RMAX

          RMAX is DOUBLE PRECISION array, dimension (3)
          Value of the largest test ratio.
          RMAX(1) = largest ratio comparing different calls to DTRSNA
          RMAX(2) = largest error in reciprocal condition
                    numbers taking their conditioning into account
          RMAX(3) = largest error in reciprocal condition
                    numbers not taking their conditioning into
                    account (may be larger than RMAX(2))


LMAX

          LMAX is INTEGER array, dimension (3)
          LMAX(i) is example number where largest test ratio
          RMAX(i) is achieved. Also:
          If DGEHRD returns INFO nonzero on example i, LMAX(1)=i
          If DHSEQR returns INFO nonzero on example i, LMAX(2)=i
          If DTRSNA returns INFO nonzero on example i, LMAX(3)=i


NINFO

          NINFO is INTEGER array, dimension (3)
          NINFO(1) = No. of times DGEHRD returned INFO nonzero
          NINFO(2) = No. of times DHSEQR returned INFO nonzero
          NINFO(3) = No. of times DTRSNA returned INFO nonzero


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 dget38 (double precision, dimension( 3 ) RMAX, integer, dimension( 3 ) LMAX, integer, dimension( 3 ) NINFO, integer KNT, integer NIN)

DGET38

Purpose:

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


 

Parameters:

RMAX

          RMAX is DOUBLE PRECISION array, dimension (3)
          Values of the largest test ratios.
          RMAX(1) = largest residuals from DHST01 or comparing
                    different calls to DTRSEN
          RMAX(2) = largest error in reciprocal condition
                    numbers taking their conditioning into account
          RMAX(3) = largest error in reciprocal condition
                    numbers not taking their conditioning into
                    account (may be larger than RMAX(2))


LMAX

          LMAX is INTEGER array, dimension (3)
          LMAX(i) is example number where largest test ratio
          RMAX(i) is achieved. Also:
          If DGEHRD returns INFO nonzero on example i, LMAX(1)=i
          If DHSEQR returns INFO nonzero on example i, LMAX(2)=i
          If DTRSEN returns INFO nonzero on example i, LMAX(3)=i


NINFO

          NINFO is INTEGER array, dimension (3)
          NINFO(1) = No. of times DGEHRD returned INFO nonzero
          NINFO(2) = No. of times DHSEQR returned INFO nonzero
          NINFO(3) = No. of times DTRSEN returned INFO nonzero


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 dget39 (double precision RMAX, integer LMAX, integer NINFO, integer KNT)

DGET39

Purpose:

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


 

Parameters:

RMAX

          RMAX is DOUBLE PRECISION
          Value of the largest test ratio.


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.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dget51 (integer ITYPE, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( * ) WORK, double precision RESULT)

DGET51

Purpose:

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


 

Parameters:

ITYPE

          ITYPE is INTEGER
          Specifies the type of tests to be performed.
          =1: RESULT = | A - U B V' | / ( |A| n ulp )
          =2: RESULT = | A - B | / ( |A| n ulp )
          =3: RESULT = | I - UU' | / ( n ulp )


N

          N is INTEGER
          The size of the matrix.  If it is zero, DGET51 does nothing.
          It must be at least zero.


A

          A is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDU, N)
          The orthogonal 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 DOUBLE PRECISION array, dimension (LDV, N)
          The orthogonal 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 DOUBLE PRECISION array, dimension (2*N**2)


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 dget52 (logical LEFT, integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( lde, * ) E, integer LDE, double precision, dimension( * ) ALPHAR, double precision, dimension( * ) ALPHAI, double precision, dimension( * ) BETA, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)

DGET52

Purpose:

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


 

Parameters:

LEFT

          LEFT is LOGICAL
          =.TRUE.:  The eigenvectors in the columns of E are assumed
                    to be *left* eigenvectors.
          =.FALSE.: The eigenvectors in the columns of E are assumed
                    to be *right* eigenvectors.


N

          N is INTEGER
          The size of the matrices.  If it is zero, DGET52 does
          nothing.  It must be at least zero.


A

          A is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDE, N)
          The matrix of eigenvectors.  It must be O( 1 ).  Complex
          eigenvalues and eigenvectors always come in pairs, the
          eigenvalue and its conjugate being stored in adjacent
          elements of ALPHAR, ALPHAI, and BETA.  Thus, if a(j)/b(j)
          and a(j+1)/b(j+1) are a complex conjugate pair of
          generalized eigenvalues, then E(,j) contains the real part
          of the eigenvector and E(,j+1) contains the imaginary part.
          Note that whether E(,j) is a real eigenvector or part of a
          complex one is specified by whether ALPHAI(j) is zero or not.


LDE

          LDE is INTEGER
          The leading dimension of E.  It must be at least 1 and at
          least N.


ALPHAR

          ALPHAR is DOUBLE PRECISION array, dimension (N)
          The real parts of the values a(j) as described above, which,
          along with b(j), define the generalized eigenvalues.
          Complex eigenvalues always come in complex conjugate pairs
          a(j)/b(j) and a(j+1)/b(j+1), which are stored in adjacent
          elements in ALPHAR, ALPHAI, and BETA.  Thus, if the j-th
          and (j+1)-st eigenvalues form a pair, ALPHAR(j+1)/BETA(j+1)
          is assumed to be equal to ALPHAR(j)/BETA(j).


ALPHAI

          ALPHAI is DOUBLE PRECISION array, dimension (N)
          The imaginary parts of the values a(j) as described above,
          which, along with b(j), define the generalized eigenvalues.
          If ALPHAI(j)=0, then the eigenvalue is real, otherwise it
          is part of a complex conjugate pair.  Complex eigenvalues
          always come in complex conjugate pairs a(j)/b(j) and
          a(j+1)/b(j+1), which are stored in adjacent elements in
          ALPHAR, ALPHAI, and BETA.  Thus, if the j-th and (j+1)-st
          eigenvalues form a pair, ALPHAI(j+1)/BETA(j+1) is assumed to
          be equal to  -ALPHAI(j)/BETA(j).  Also, nonzero values in
          ALPHAI are assumed to always come in adjacent pairs.


BETA

          BETA is DOUBLE PRECISION array, dimension (N)
          The values b(j) as described above, which, along with a(j),
          define the generalized eigenvalues.


WORK

          WORK is DOUBLE PRECISION array, dimension (N**2+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 dget53 (double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision SCALE, double precision WR, double precision WI, double precision RESULT, integer INFO)

DGET53

Purpose:

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


 

Parameters:

A

          A is DOUBLE PRECISION array, dimension (LDA, 2)
          The 2x2 matrix A.


LDA

          LDA is INTEGER
          The leading dimension of A.  It must be at least 2.


B

          B is DOUBLE PRECISION array, dimension (LDB, N)
          The 2x2 upper-triangular matrix B.


LDB

          LDB is INTEGER
          The leading dimension of B.  It must be at least 2.


SCALE

          SCALE is DOUBLE PRECISION
          The "scale factor" s in the formula  s A - w B .  It is
          assumed to be non-negative.


WR

          WR is DOUBLE PRECISION
          The real part of the eigenvalue  w  in the formula
          s A - w B .


WI

          WI is DOUBLE PRECISION
          The imaginary part of the eigenvalue  w  in the formula
          s A - w B .


RESULT

          RESULT is DOUBLE PRECISION
          If INFO is 2 or less, the value computed by the test
             described above.
          If INFO=3, this will just be 1/ulp.


INFO

          INFO is INTEGER
          =0:  The input data pass the "safety checks".
          =1:  s*norm(A) + |w|*norm(B) > 1/safe_minimum.
          =2:  ulp*max( s*norm(A), |w|*norm(B) ) < safe_minimum
          =3:  same as INFO=2, but  s  and  w  could not be scaled so
               as to compute the test.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dget54 (integer N, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( lds, * ) S, integer LDS, double precision, dimension( ldt, * ) T, integer LDT, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( * ) WORK, double precision RESULT)

DGET54

Purpose:

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


 

Parameters:

N

          N is INTEGER
          The size of the matrix.  If it is zero, DGET54 does nothing.
          It must be at least zero.


A

          A is DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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 dglmts (integer N, integer M, integer P, double precision, dimension( lda, * ) A, double precision, dimension( lda, * ) AF, integer LDA, double precision, dimension( ldb, * ) B, double precision, dimension( ldb, * ) BF, integer LDB, double precision, dimension( * ) D, double precision, dimension( * ) DF, double precision, dimension( * ) X, double precision, dimension( * ) U, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision RESULT)

DGLMTS

Purpose:

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


 

Parameters:

N

          N is INTEGER
          The number of rows of the matrices A and B.  N >= 0.


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


AF

          AF is DOUBLE PRECISION array, dimension (LDA,M)


LDA

          LDA is INTEGER
          The leading dimension of the arrays A, AF. LDA >= max(M,N).


B

          B is DOUBLE PRECISION array, dimension (LDB,P)
          The N-by-P matrix A.


BF

          BF is DOUBLE PRECISION array, dimension (LDB,P)


LDB

          LDB is INTEGER
          The leading dimension of the arrays B, BF. LDB >= max(P,N).


D

          D is DOUBLE PRECISION array, dimension( N )
          On input, the left hand side of the GLM.


DF

          DF is DOUBLE PRECISION array, dimension( N )


X

          X is DOUBLE PRECISION array, dimension( M )
          solution vector X in the GLM problem.


U

          U is DOUBLE PRECISION array, dimension( P )
          solution vector U in the GLM problem.


WORK

          WORK is DOUBLE PRECISION 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 dgqrts (integer N, integer M, integer P, double precision, dimension( lda, * ) A, double precision, dimension( lda, * ) AF, double precision, dimension( lda, * ) Q, double precision, dimension( lda, * ) R, integer LDA, double precision, dimension( * ) TAUA, double precision, dimension( ldb, * ) B, double precision, dimension( ldb, * ) BF, double precision, dimension( ldb, * ) Z, double precision, dimension( ldb, * ) T, double precision, dimension( ldb, * ) BWK, integer LDB, double precision, dimension( * ) TAUB, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 4 ) RESULT)

DGQRTS

Purpose:

 DGQRTS tests DGGQRF, which computes the GQR factorization of an
 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 DOUBLE PRECISION array, dimension (LDA,M)
          The N-by-M matrix A.


AF

          AF is DOUBLE PRECISION array, dimension (LDA,N)
          Details of the GQR factorization of A and B, as returned
          by DGGQRF, see SGGQRF for further details.


Q

          Q is DOUBLE PRECISION array, dimension (LDA,N)
          The M-by-M orthogonal matrix Q.


R

          R is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (min(M,N))
          The scalar factors of the elementary reflectors, as returned
          by DGGQRF.


B

          B is DOUBLE PRECISION array, dimension (LDB,P)
          On entry, the N-by-P matrix A.


BF

          BF is DOUBLE PRECISION array, dimension (LDB,N)
          Details of the GQR factorization of A and B, as returned
          by DGGQRF, see SGGQRF for further details.


Z

          Z is DOUBLE PRECISION array, dimension (LDB,P)
          The P-by-P orthogonal matrix Z.


T

          T is DOUBLE PRECISION array, dimension (LDB,max(P,N))


BWK

          BWK is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (min(P,N))
          The scalar factors of the elementary reflectors, as returned
          by DGGRQF.


WORK

          WORK is DOUBLE PRECISION 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 dgrqts (integer M, integer P, integer N, double precision, dimension( lda, * ) A, double precision, dimension( lda, * ) AF, double precision, dimension( lda, * ) Q, double precision, dimension( lda, * ) R, integer LDA, double precision, dimension( * ) TAUA, double precision, dimension( ldb, * ) B, double precision, dimension( ldb, * ) BF, double precision, dimension( ldb, * ) Z, double precision, dimension( ldb, * ) T, double precision, dimension( ldb, * ) BWK, integer LDB, double precision, dimension( * ) TAUB, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 4 ) RESULT)

DGRQTS

Purpose:

 DGRQTS tests DGGRQF, which computes the GRQ factorization of an
 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 DOUBLE PRECISION array, dimension (LDA,N)
          The M-by-N matrix A.


AF

          AF is DOUBLE PRECISION array, dimension (LDA,N)
          Details of the GRQ factorization of A and B, as returned
          by DGGRQF, see SGGRQF for further details.


Q

          Q is DOUBLE PRECISION array, dimension (LDA,N)
          The N-by-N orthogonal matrix Q.


R

          R is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (min(M,N))
          The scalar factors of the elementary reflectors, as returned
          by DGGQRC.


B

          B is DOUBLE PRECISION array, dimension (LDB,N)
          On entry, the P-by-N matrix A.


BF

          BF is DOUBLE PRECISION array, dimension (LDB,N)
          Details of the GQR factorization of A and B, as returned
          by DGGRQF, see SGGRQF for further details.


Z

          Z is DOUBLE PRECISION array, dimension (LDB,P)
          The P-by-P orthogonal matrix Z.


T

          T is DOUBLE PRECISION array, dimension (LDB,max(P,N))


BWK

          BWK is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (min(P,N))
          The scalar factors of the elementary reflectors, as returned
          by DGGRQF.


WORK

          WORK is DOUBLE PRECISION 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 dgsvts3 (integer M, integer P, integer N, double precision, dimension( lda, * ) A, double precision, dimension( lda, * ) AF, integer LDA, double precision, dimension( ldb, * ) B, double precision, dimension( ldb, * ) BF, integer LDB, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( * ) ALPHA, double precision, dimension( * ) BETA, double precision, dimension( ldr, * ) R, integer LDR, integer, dimension( * ) IWORK, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 6 ) RESULT)

DGSVTS3

Purpose:

 DGSVTS3 tests DGGSVD3, which computes the GSVD of an 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 DOUBLE PRECISION array, dimension (LDA,M)
          The M-by-N matrix A.


AF

          AF is DOUBLE PRECISION array, dimension (LDA,N)
          Details of the GSVD of A and B, as returned by DGGSVD3,
          see DGGSVD3 for further details.


LDA

          LDA is INTEGER
          The leading dimension of the arrays A and AF.
          LDA >= max( 1,M ).


B

          B is DOUBLE PRECISION array, dimension (LDB,P)
          On entry, the P-by-N matrix B.


BF

          BF is DOUBLE PRECISION array, dimension (LDB,N)
          Details of the GSVD of A and B, as returned by DGGSVD3,
          see DGGSVD3 for further details.


LDB

          LDB is INTEGER
          The leading dimension of the arrays B and BF.
          LDB >= max(1,P).


U

          U is DOUBLE PRECISION 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).


V

          V is DOUBLE PRECISION array, dimension(LDV,M)
          The P by P orthogonal matrix V.


LDV

          LDV is INTEGER
          The leading dimension of the array V. LDV >= max(1,P).


Q

          Q is DOUBLE PRECISION array, dimension(LDQ,N)
          The N by N orthogonal 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 DGGSVD3 for details.


R

          R is DOUBLE PRECISION 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 DOUBLE PRECISION 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 dhst01 (integer N, integer ILO, integer IHI, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldh, * ) H, integer LDH, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( 2 ) RESULT)

DHST01

Purpose:

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


 

Parameters:

N

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


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 DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDH,N)
          The upper Hessenberg matrix H from the reduction A = Q*H*Q'
          as computed by DGEHRD.  H is assumed to be zero below the
          first subdiagonal.


LDH

          LDH is INTEGER
          The leading dimension of the array H.  LDH >= max(1,N).


Q

          Q is DOUBLE PRECISION array, dimension (LDQ,N)
          The orthogonal matrix Q from the reduction A = Q*H*Q' as
          computed by DGEHRD + DORGHR.


LDQ

          LDQ is INTEGER
          The leading dimension of the array Q.  LDQ >= max(1,N).


WORK

          WORK is DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of the array WORK.  LWORK >= 2*N*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 dlafts (character*3 TYPE, integer M, integer N, integer IMAT, integer NTESTS, double precision, dimension( * ) RESULT, integer, dimension( 4 ) ISEED, double precision THRESH, integer IOUNIT, integer IE)

DLAFTS

Purpose:

    DLAFTS tests the result vector against the threshold value to
    see which tests for this matrix type failed to pass the threshold.
    Output is to the file given by unit IOUNIT.


 

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


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dlahd2 (integer IOUNIT, character*3 PATH)

DLAHD2

Purpose:

 DLAHD2 prints header information for the different test paths.


 

Parameters:

IOUNIT

          IOUNIT is INTEGER.
          On entry, IOUNIT specifies the unit number to which the
          header information should be printed.


PATH

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


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine dlarfy (character UPLO, integer N, double precision, dimension( * ) V, integer INCV, double precision TAU, double precision, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) WORK)

DLARFY

Purpose:

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


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          symmetric matrix C is stored.
          = 'U':  Upper triangle
          = 'L':  Lower triangle


N

          N is INTEGER
          The number of rows and columns of the matrix C.  N >= 0.


V

          V is DOUBLE PRECISION 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 DOUBLE PRECISION
          The value tau as described above.


C

          C is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (N)


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dlarhs (character*3 PATH, character XTYPE, character UPLO, character TRANS, integer M, integer N, integer KL, integer KU, integer NRHS, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldx, * ) X, integer LDX, double precision, dimension( ldb, * ) B, integer LDB, integer, dimension( 4 ) ISEED, integer INFO)

DLARHS

Purpose:

 DLARHS chooses a set of NRHS random solution vectors and sets
 up the right hand sides for the linear system
    op( A ) * X = B,
 where op( A ) may be A or A' (transpose of A).


 

Parameters:

PATH

          PATH is CHARACTER*3
          The type of the real matrix A.  PATH may be given in any
          combination of upper and lower case.  Valid types include
             xGE:  General m x n matrix
             xGB:  General banded matrix
             xPO:  Symmetric positive definite, 2-D storage
             xPP:  Symmetric positive definite packed
             xPB:  Symmetric positive definite banded
             xSY:  Symmetric indefinite, 2-D storage
             xSP:  Symmetric indefinite packed
             xSB:  Symmetric indefinite banded
             xTR:  Triangular
             xTP:  Triangular packed
             xTB:  Triangular banded
             xQR:  General m x n matrix
             xLQ:  General m x n matrix
             xQL:  General m x n matrix
             xRQ:  General m x n matrix
          where the leading character indicates the precision.


XTYPE

          XTYPE is CHARACTER*1
          Specifies how the exact solution X will be determined:
          = 'N':  New solution; generate a random X.
          = 'C':  Computed; use value of X on entry.


UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          matrix A is stored, if A is symmetric.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the operation applied to the matrix A.
          = 'N':  System is  A * x = b
          = 'T':  System is  A'* x = b
          = 'C':  System is  A'* x = b


M

          M is INTEGER
          The number or rows of the matrix A.  M >= 0.


N

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


KL

          KL is INTEGER
          Used only if A is a band matrix; specifies the number of
          subdiagonals of A if A is a general band matrix or if A is
          symmetric or triangular and UPLO = 'L'; specifies the number
          of superdiagonals of A if A is symmetric or triangular and
          UPLO = 'U'.  0 <= KL <= M-1.


KU

          KU is INTEGER
          Used only if A is a general band matrix or if A is
          triangular.
          If PATH = xGB, specifies the number of superdiagonals of A,
          and 0 <= KU <= N-1.
          If PATH = xTR, xTP, or xTB, specifies whether or not the
          matrix has unit diagonal:
          = 1:  matrix has non-unit diagonal (default)
          = 2:  matrix has unit diagonal


NRHS

          NRHS is INTEGER
          The number of right hand side vectors in the system A*X = B.


A

          A is DOUBLE PRECISION 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) DOUBLE PRECISION array, dimension(LDX,NRHS)
          On entry, if XTYPE = 'C' (for 'Computed'), then X contains
          the exact solution to the system of linear equations.
          On exit, if XTYPE = 'N' (for 'New'), then X is initialized
          with random values.


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 DOUBLE PRECISION array, dimension (LDB,NRHS)
          The right hand side vector(s) for the system of equations,
          computed from B = op(A) * X, where op(A) is determined by
          TRANS.


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
          DLATMS).  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 dlasum (character*3 TYPE, integer IOUNIT, integer IE, integer NRUN)

DLASUM

Purpose:

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


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dlatb9 (character*3 PATH, integer IMAT, integer M, integer P, integer N, character TYPE, integer KLA, integer KUA, integer KLB, integer KUB, double precision ANORM, double precision BNORM, integer MODEA, integer MODEB, double precision CNDNMA, double precision CNDNMB, character DISTA, character DISTB)

DLATB9

Purpose:

 DLATB9 sets parameters for the matrix generator based on the type of
 matrix to be generated.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name.


IMAT

          IMAT is INTEGER
          An integer key describing which matrix to generate for this
          path.
          = 1:   A: diagonal, B: upper triangular
          = 2:   A: upper triangular, B: upper triangular
          = 3:   A: lower triangular, B: upper triangular
          Else:  A: general dense, B: general dense


M

          M is INTEGER
          The number of rows in the matrix to be generated.


P

          P is INTEGER


N

          N is INTEGER
          The number of columns in the matrix to be generated.


TYPE

          TYPE is CHARACTER*1
          The type of the matrix to be generated:
          = 'S':  symmetric matrix;
          = 'P':  symmetric positive (semi)definite matrix;
          = 'N':  nonsymmetric matrix.


KLA

          KLA is INTEGER
          The lower band width of the matrix to be generated.


KUA

          KUA is INTEGER
          The upper band width of the matrix to be generated.


KLB

          KLB is INTEGER
          The lower band width of the matrix to be generated.


KUB

          KUA is INTEGER
          The upper band width of the matrix to be generated.


ANORM

          ANORM is DOUBLE PRECISION
          The desired norm of the matrix to be generated.  The diagonal
          matrix of singular values or eigenvalues is scaled by this
          value.


BNORM

          BNORM is DOUBLE PRECISION
          The desired norm of the matrix to be generated.  The diagonal
          matrix of singular values or eigenvalues is scaled by this
          value.


MODEA

          MODEA is INTEGER
          A key indicating how to choose the vector of eigenvalues.


MODEB

          MODEB is INTEGER
          A key indicating how to choose the vector of eigenvalues.


CNDNMA

          CNDNMA is DOUBLE PRECISION
          The desired condition number.


CNDNMB

          CNDNMB is DOUBLE PRECISION
          The desired condition number.


DISTA

          DISTA is CHARACTER*1
          The type of distribution to be used by the random number
          generator.


DISTB

          DISTB is CHARACTER*1
          The type of distribution to be used by the random number
          generator.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dlatm4 (integer ITYPE, integer N, integer NZ1, integer NZ2, integer ISIGN, double precision AMAGN, double precision RCOND, double precision TRIANG, integer IDIST, integer, dimension( 4 ) ISEED, double precision, dimension( lda, * ) A, integer LDA)

DLATM4

Purpose:

 DLATM4 generates basic square matrices, which may later be
 multiplied by others in order to produce test matrices.  It is
 intended mainly to be used to test the generalized eigenvalue
 routines.
 It first generates the diagonal and (possibly) subdiagonal,
 according to the value of ITYPE, NZ1, NZ2, ISIGN, AMAGN, and RCOND.
 It then fills in the upper triangle with random numbers, if TRIANG is
 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 ISIGN.
          Special types:
          = 0:  the zero matrix.
          = 1:  the identity.
          = 2:  a transposed Jordan block.
          = 3:  If N is odd, then a k+1 x k+1 transposed Jordan block
                followed by a k x k identity block, where k=(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 DLARND.)


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.


ISIGN

          ISIGN is INTEGER
          = 0: The sign of the diagonal and subdiagonal entries will
               be left unchanged.
          = 1: The diagonal and subdiagonal entries will have their
               sign changed at random.
          = 2: If ITYPE is 2 or 3, then the same as ISIGN=1.
               Otherwise, with probability 0.5, odd-even pairs of
               diagonal entries A(2*j-1,2*j-1), A(2*j,2*j) will be
               converted to a 2x2 block by pre- and post-multiplying
               by distinct random orthogonal rotations.  The remaining
               diagonal entries will have their sign changed at random.


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
          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
          Specifies the type of distribution to be used to generate a
          random matrix.
          = 1:  UNIFORM( 0, 1 )
          = 2:  UNIFORM( -1, 1 )
          = 3:  NORMAL ( 0, 1 )


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 DLATM4 to continue the same
          random number sequence.
          Note: ISEED(4) should be odd, for the random number generator
          used at present.


A

          A is DOUBLE PRECISION 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 dlctes (double precision ZR, double precision ZI, double precision D)

DLCTES

Purpose:

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


 

Parameters:

ZR

          ZR is DOUBLE PRECISION
          The numerator of the real part of a complex eigenvalue
          (ZR/D) + i*(ZI/D).


ZI

          ZI is DOUBLE PRECISION
          The numerator of the imaginary part of a complex eigenvalue
          (ZR/D) + i*(ZI).


D

          D is DOUBLE PRECISION
          The denominator part of a complex eigenvalue
          (ZR/D) + i*(ZI/D).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

June 2016

logical function dlctsx (double precision AR, double precision AI, double precision BETA)

DLCTSX

Purpose:

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


 

Parameters:

AR

          AR is DOUBLE PRECISION
          The numerator of the real part of a complex eigenvalue
          (AR/BETA) + i*(AI/BETA).


AI

          AI is DOUBLE PRECISION
          The numerator of the imaginary part of a complex eigenvalue
          (AR/BETA) + i*(AI).


BETA

          BETA is DOUBLE PRECISION
          The denominator part of a complex eigenvalue
          (AR/BETA) + i*(AI/BETA).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dlsets (integer M, integer P, integer N, double precision, dimension( lda, * ) A, double precision, dimension( lda, * ) AF, integer LDA, double precision, dimension( ldb, * ) B, double precision, dimension( ldb, * ) BF, integer LDB, double precision, dimension( * ) C, double precision, dimension( * ) CF, double precision, dimension( * ) D, double precision, dimension( * ) DF, double precision, dimension( * ) X, double precision, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)

DLSETS

Purpose:

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


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


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


AF

          AF is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (LDB,N)
          The P-by-N matrix A.


BF

          BF is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension( M )
          the vector C in the LSE problem.


CF

          CF is DOUBLE PRECISION array, dimension( M )


D

          D is DOUBLE PRECISION array, dimension( P )
          the vector D in the LSE problem.


DF

          DF is DOUBLE PRECISION array, dimension( P )


X

          X is DOUBLE PRECISION array, dimension( N )
          solution vector X in the LSE problem.


WORK

          WORK is DOUBLE PRECISION 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 dort01 (character ROWCOL, integer M, integer N, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) WORK, integer LWORK, double precision RESID)

DORT01

Purpose:

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


 

Parameters:

ROWCOL

          ROWCOL is CHARACTER
          Specifies whether the rows or columns of U should be checked
          for orthogonality.  Used only if M = N.
          = 'R':  Check for orthogonal rows of U
          = 'C':  Check for orthogonal columns of U


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 DOUBLE PRECISION array, dimension (LDU,N)
          The orthogonal matrix U.  U is checked for orthogonal columns
          if m > n or if m = n and ROWCOL = 'C'.  U is checked for
          orthogonal rows if m < n or if m = n and ROWCOL = 'R'.


LDU

          LDU is INTEGER
          The leading dimension of the array U.  LDU >= max(1,M).


WORK

          WORK is DOUBLE PRECISION array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of the array WORK.  For best performance, LWORK
          should be at least N*(N+1) if ROWCOL = 'C' or M*(M+1) if
          ROWCOL = 'R', but the test will be done even if LWORK is 0.


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 dort03 (character*( * ) RC, integer MU, integer MV, integer N, integer K, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( * ) WORK, integer LWORK, double precision RESULT, integer INFO)

DORT03

Purpose:

 DORT03 compares two orthogonal matrices U and V to see if their
 corresponding rows or columns span the same spaces.  The rows are
 checked if RC = 'R', and the columns are checked if RC = 'C'.
 RESULT is the maximum of
    | V*V' - I | / ( MV ulp ), if RC = 'R', or
    | V'*V - I | / ( MV ulp ), if RC = 'C',
 and the maximum over rows (or columns) 1 to K of
    | U(i) - S*V(i) |/ ( N ulp )
 where S is +-1 (chosen to minimize the expression), U(i) is the 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 DORT03 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 DORT03 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
          DORT03 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 DOUBLE PRECISION array, dimension (LDU,N)
          The first matrix to compare.  If RC = 'R', U is MU by N, and
          if RC = 'C', U is N by MU.


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 DOUBLE PRECISION array, dimension (LDV,N)
          The second matrix to compare.  If RC = 'R', V is MV by N, and
          if RC = 'C', V is N by MV.


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 DOUBLE PRECISION 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.


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

subroutine dsbt21 (character UPLO, integer N, integer KA, integer KS, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)

DSBT21

Purpose:

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


 

Parameters:

UPLO

          UPLO is CHARACTER
          If UPLO='U', the upper triangle of A and V will be used and
          the (strictly) lower triangle will not be referenced.
          If UPLO='L', the lower triangle of A and V will be used and
          the (strictly) upper triangle will not be referenced.


N

          N is INTEGER
          The size of the matrix.  If it is zero, DSBT21 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 DOUBLE PRECISION array, dimension (LDA, N)
          The original (unfactored) matrix.  It is assumed to be
          symmetric, and only the upper (UPLO='U') or only the lower
          (UPLO='L') will be referenced.


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 DOUBLE PRECISION array, dimension (LDU, N)
          The orthogonal matrix in the decomposition, expressed as a
          dense matrix (i.e., not as a product of Householder
          transformations, Givens transformations, etc.)


LDU

          LDU is INTEGER
          The leading dimension of U.  LDU must be at least N and
          at least 1.


WORK

          WORK is DOUBLE PRECISION array, dimension (N**2+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 dsgt01 (integer ITYPE, character UPLO, integer N, integer M, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( ldb, * ) B, integer LDB, double precision, dimension( ldz, * ) Z, integer LDZ, double precision, dimension( * ) D, double precision, dimension( * ) WORK, double precision, dimension( * ) RESULT)

DSGT01

Purpose:

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


 

Parameters:

ITYPE

          ITYPE is INTEGER
          The form of the symmetric generalized eigenproblem.
          = 1:  A*z = (lambda)*B*z
          = 2:  A*B*z = (lambda)*z
          = 3:  B*A*z = (lambda)*z


UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          symmetric matrices A and B is stored.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

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


M

          M is INTEGER
          The number of eigenvalues found.  0 <= M <= N.


A

          A is DOUBLE PRECISION array, dimension (LDA, N)
          The original symmetric matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


B

          B is DOUBLE PRECISION array, dimension (LDB, N)
          The original symmetric positive definite matrix B.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


Z

          Z is DOUBLE PRECISION 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 DOUBLE PRECISION array, dimension (N*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 dslect (double precision ZR, double precision ZI)

DSLECT

Purpose:

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


 

Parameters:

ZR

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


ZI

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


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

June 2016

subroutine dspt21 (integer ITYPE, character UPLO, integer N, integer KBAND, double precision, dimension( * ) AP, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) VP, double precision, dimension( * ) TAU, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)

DSPT21

Purpose:

 DSPT21  generally checks a decomposition of the form
         A = U S U'
 where ' means transpose, A is symmetric (stored in packed format), U
 is orthogonal, and S is diagonal (if KBAND=0) or symmetric
 tridiagonal (if KBAND=1).  If ITYPE=1, then U is represented as a
 dense matrix, otherwise the U is expressed as a product of
 Householder transformations, whose vectors are stored in the array
 "V" and whose scaling constants are in "TAU"; we shall use the
 letter "V" to refer to the product of Householder transformations
 (which should be equal to U).
 Specifically, if ITYPE=1, then:
         RESULT(1) = | A - U S U' | / ( |A| n ulp ) *andC>         RESULT(2) = | I - UU' | / ( n ulp )
 If ITYPE=2, then:
         RESULT(1) = | A - V S V' | / ( |A| n ulp )
 If ITYPE=3, then:
         RESULT(1) = | I - VU' | / ( n ulp )
 Packed storage means that, for example, if UPLO='U', then the columns
 of the upper triangle of A are stored one after another, so that
 A(1,j+1) immediately follows A(j,j) in the array AP.  Similarly, if
 UPLO='L', then the columns of the lower triangle of A are stored one
 after another in AP, so that A(j+1,j+1) immediately follows A(n,j)
 in the array AP.  This means that A(i,j) is stored in:
    AP( i + j*(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)'
    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)'
    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 orthogonal matrix:
             RESULT(1) = | A - U S U' | / ( |A| n ulp )   *andC>             RESULT(2) = | I - UU' | / ( n ulp )
          2: U expressed as a product V of Housholder transformations:
             RESULT(1) = | A - V S V' | / ( |A| n ulp )
          3: U expressed both as a dense orthogonal matrix and
             as a product of Housholder transformations:
             RESULT(1) = | I - VU' | / ( n ulp )


UPLO

          UPLO is CHARACTER
          If UPLO='U', AP and VP are considered to contain the upper
          triangle of A and V.
          If UPLO='L', AP and VP are considered to contain the lower
          triangle of A and V.


N

          N is INTEGER
          The size of the matrix.  If it is zero, DSPT21 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 DOUBLE PRECISION array, dimension (N*(N+1)/2)
          The original (unfactored) matrix.  It is assumed to be
          symmetric, and contains the columns of just the upper
          triangle (UPLO='U') or only the lower triangle (UPLO='L'),
          packed one after another.


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 DOUBLE PRECISION array, dimension (LDU, N)
          If ITYPE=1 or 3, this contains the orthogonal matrix in
          the decomposition, expressed as a dense matrix.  If ITYPE=2,
          then it is not referenced.


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 orthogonal matrix
          in the decomposition, as described in purpose.
          *NOTE* If ITYPE=2 or 3, V is modified and restored.  The
          subdiagonal (if UPLO='L') or the superdiagonal (if UPLO='U')
          is set to one, and later reset to its original value, during
          the course of the calculation.
          If ITYPE=1, then it is neither referenced nor modified.


TAU

          TAU is DOUBLE PRECISION array, dimension (N)
          If ITYPE >= 2, then TAU(j) is the scalar factor of
          v(j) v(j)' in the Householder transformation H(j) of
          the product  U = H(1)...H(n-2)
          If ITYPE < 2, then TAU is not referenced.


WORK

          WORK is DOUBLE PRECISION array, dimension (N**2+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 dstech (integer N, double precision, dimension( * ) A, double precision, dimension( * ) B, double precision, dimension( * ) EIG, double precision TOL, double precision, dimension( * ) WORK, integer INFO)

DSTECH

Purpose:

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


 

Parameters:

N

          N is INTEGER
          The dimension of the tridiagonal matrix T.


A

          A is DOUBLE PRECISION array, dimension (N)
          The diagonal entries of the tridiagonal matrix T.


B

          B is DOUBLE PRECISION array, dimension (N-1)
          The offdiagonal entries of the tridiagonal matrix T.


EIG

          EIG is DOUBLE PRECISION array, dimension (N)
          The purported eigenvalues to be checked.


TOL

          TOL is DOUBLE PRECISION
          Error tolerance for checking, a multiple of the
          machine precision.


WORK

          WORK is DOUBLE PRECISION array, dimension (N)


INFO

          INFO is INTEGER
          0  if the eigenvalues are all correct (to within
             1 +- TOL*MAZHEPS*MAXEIG)
          >0 if the interval containing the INFO-th eigenvalue
             contains the incorrect number of eigenvalues.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dstect (integer N, double precision, dimension( * ) A, double precision, dimension( * ) B, double precision SHIFT, integer NUM)

DSTECT

Purpose:

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


 

Parameters:

N

          N is INTEGER
          The dimension of the tridiagonal matrix T.


A

          A is DOUBLE PRECISION array, dimension (N)
          The diagonal entries of the tridiagonal matrix T.


B

          B is DOUBLE PRECISION array, dimension (N-1)
          The offdiagonal entries of the tridiagonal matrix T.


SHIFT

          SHIFT is DOUBLE PRECISION
          The shift, used as described under Purpose.


NUM

          NUM is INTEGER
          The number of eigenvalues of T less than or equal
          to SHIFT.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dstt21 (integer N, integer KBAND, double precision, dimension( * ) AD, double precision, dimension( * ) AE, double precision, dimension( * ) SD, double precision, dimension( * ) SE, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)

DSTT21

Purpose:

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


 

Parameters:

N

          N is INTEGER
          The size of the matrix.  If it is zero, DSTT21 does nothing.
          It must be at least zero.


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 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 (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 DOUBLE PRECISION array, dimension (LDU, N)
          The orthogonal matrix in the decomposition.


LDU

          LDU is INTEGER
          The leading dimension of U.  LDU must be at least N.


WORK

          WORK is DOUBLE PRECISION array, dimension (N*(N+1))


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 dstt22 (integer N, integer M, integer KBAND, double precision, dimension( * ) AD, double precision, dimension( * ) AE, double precision, dimension( * ) SD, double precision, dimension( * ) SE, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldwork, * ) WORK, integer LDWORK, double precision, dimension( 2 ) RESULT)

DSTT22

Purpose:

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


 

Parameters:

N

          N is INTEGER
          The size of the matrix.  If it is zero, DSTT22 does nothing.
          It must be at least zero.


M

          M is INTEGER
          The number of eigenpairs to check.  If it is zero, DSTT22
          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 symmetric tridiagonal.


AE

          AE is DOUBLE PRECISION array, dimension (N)
          The off-diagonal of the original (unfactored) matrix A.  A
          is assumed to be symmetric tridiagonal.  AE(1) is ignored,
          AE(2) is the (1,2) and (2,1) element, etc.


SD

          SD is DOUBLE PRECISION array, dimension (N)
          The diagonal of the (symmetric tri-) diagonal matrix S.


SE

          SE is DOUBLE PRECISION array, dimension (N)
          The off-diagonal of the (symmetric tri-) diagonal matrix S.
          Not referenced if KBSND=0.  If KBAND=1, then AE(1) is
          ignored, SE(2) is the (1,2) and (2,1) element, etc.


U

          U is DOUBLE PRECISION array, dimension (LDU, N)
          The orthogonal matrix in the decomposition.


LDU

          LDU is INTEGER
          The leading dimension of U.  LDU must be at least N.


WORK

          WORK is DOUBLE PRECISION array, dimension (LDWORK, M+1)


LDWORK

          LDWORK is INTEGER
          The leading dimension of WORK.  LDWORK must be at least
          max(1,M).


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 dsvdch (integer N, double precision, dimension( * ) S, double precision, dimension( * ) E, double precision, dimension( * ) SVD, double precision TOL, integer INFO)

DSVDCH

Purpose:

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


 

Parameters:

N

          N is INTEGER
          The dimension of the bidiagonal matrix B.


S

          S is DOUBLE PRECISION array, dimension (N)
          The diagonal entries of the bidiagonal matrix B.


E

          E is DOUBLE PRECISION array, dimension (N-1)
          The superdiagonal entries of the bidiagonal matrix B.


SVD

          SVD is DOUBLE PRECISION array, dimension (N)
          The computed singular values to be checked.


TOL

          TOL is DOUBLE PRECISION
          Error tolerance for checking, a multiplier of the
          machine precision.


INFO

          INFO is INTEGER
          =0 if the singular values are all correct (to within
             1 +- TOL*MAZHEPS)
          >0 if the interval containing the INFO-th singular value
             contains the incorrect number of singular values.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dsvdct (integer N, double precision, dimension( * ) S, double precision, dimension( * ) E, double precision SHIFT, integer NUM)

DSVDCT

Purpose:

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


 

Parameters:

N

          N is INTEGER
          The dimension of the bidiagonal matrix B.


S

          S is DOUBLE PRECISION array, dimension (N)
          The diagonal entries of the bidiagonal matrix B.


E

          E is DOUBLE PRECISION array of dimension (N-1)
          The superdiagonal entries of the bidiagonal matrix B.


SHIFT

          SHIFT is DOUBLE PRECISION
          The shift, used as described under Purpose.


NUM

          NUM is INTEGER
          The number of eigenvalues of T less than or equal to SHIFT.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

double precision function dsxt1 (integer IJOB, double precision, dimension( * ) D1, integer N1, double precision, dimension( * ) D2, integer N2, double precision ABSTOL, double precision ULP, double precision UNFL)

DSXT1

Purpose:

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


 

Parameters:

IJOB

          IJOB is INTEGER
          Specifies the type of tests to be performed.  (See above.)


D1

          D1 is DOUBLE PRECISION array, dimension (N1)
          The first array.  D1 should be in increasing order, i.e.,
          D1(j) <= D1(j+1).


N1

          N1 is INTEGER
          The length of D1.


D2

          D2 is DOUBLE PRECISION array, dimension (N2)
          The second array.  D2 should be in increasing order, i.e.,
          D2(j) <= D2(j+1).


N2

          N2 is INTEGER
          The length of D2.


ABSTOL

          ABSTOL is DOUBLE PRECISION
          The absolute tolerance, used as a measure of the error.


ULP

          ULP is DOUBLE PRECISION
          Machine precision.


UNFL

          UNFL is DOUBLE PRECISION
          The smallest positive number whose reciprocal does not
          overflow.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine dsyt21 (integer ITYPE, character UPLO, integer N, integer KBAND, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( * ) TAU, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)

DSYT21

Purpose:

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


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, DSYT21 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 DOUBLE PRECISION array, dimension (LDA, N)
          The original (unfactored) matrix.  It is assumed to be
          symmetric, and only the upper (UPLO='U') or only the lower
          (UPLO='L') will be referenced.


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 DOUBLE PRECISION array, dimension (LDU, N)
          If ITYPE=1 or 3, this contains the orthogonal matrix in
          the decomposition, expressed as a dense matrix.  If ITYPE=2,
          then it is not referenced.


LDU

          LDU is INTEGER
          The leading dimension of U.  LDU must be at least N and
          at least 1.


V

          V is DOUBLE PRECISION array, dimension (LDV, N)
          If ITYPE=2 or 3, the columns of this array contain the
          Householder vectors used to describe the orthogonal matrix
          in the decomposition.  If UPLO='L', then the vectors are in
          the lower triangle, if UPLO='U', then in the upper
          triangle.
          *NOTE* If ITYPE=2 or 3, V is modified and restored.  The
          subdiagonal (if UPLO='L') or the superdiagonal (if UPLO='U')
          is set to one, and later reset to its original value, during
          the course of the calculation.
          If ITYPE=1, then it is neither referenced nor modified.


LDV

          LDV is INTEGER
          The leading dimension of V.  LDV must be at least N and
          at least 1.


TAU

          TAU is DOUBLE PRECISION array, dimension (N)
          If ITYPE >= 2, then TAU(j) is the scalar factor of
          v(j) v(j)' in the Householder transformation H(j) of
          the product  U = H(1)...H(n-2)
          If ITYPE < 2, then TAU is not referenced.


WORK

          WORK is DOUBLE PRECISION array, dimension (2*N**2)


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 dsyt22 (integer ITYPE, character UPLO, integer N, integer M, integer KBAND, double precision, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D, double precision, dimension( * ) E, double precision, dimension( ldu, * ) U, integer LDU, double precision, dimension( ldv, * ) V, integer LDV, double precision, dimension( * ) TAU, double precision, dimension( * ) WORK, double precision, dimension( 2 ) RESULT)

DSYT22

Purpose:

      DSYT22  generally checks a decomposition of the form
              A U = U S
      where A is symmetric, the columns of U are orthonormal, and S
      is diagonal (if KBAND=0) or symmetric tridiagonal (if
      KBAND=1).  If ITYPE=1, then U is represented as a dense matrix,
      otherwise the U is expressed as a product of Householder
      transformations, whose vectors are stored in the array "V" and
      whose scaling constants are in "TAU"; we shall use the letter
      "V" to refer to the product of Householder transformations
      (which should be equal to U).
      Specifically, if ITYPE=1, then:
              RESULT(1) = | U' A U - S | / ( |A| m ulp ) *andC>              RESULT(2) = | I - U'U | / ( m ulp )


 

  ITYPE   INTEGER
          Specifies the type of tests to be performed.
          1: U expressed as a dense orthogonal matrix:
             RESULT(1) = | A - U S U' | / ( |A| n ulp )   *andC>             RESULT(2) = | I - UU' | / ( n ulp )
  UPLO    CHARACTER
          If UPLO='U', the upper triangle of A will be used and the
          (strictly) lower triangle will not be referenced.  If
          UPLO='L', the lower triangle of A will be used and the
          (strictly) upper triangle will not be referenced.
          Not modified.
  N       INTEGER
          The size of the matrix.  If it is zero, DSYT22 does nothing.
          It must be at least zero.
          Not modified.
  M       INTEGER
          The number of columns of U.  If it is zero, DSYT22 does
          nothing.  It must be at least zero.
          Not modified.
  KBAND   INTEGER
          The bandwidth of the matrix.  It may only be zero or one.
          If zero, then S is diagonal, and E is not referenced.  If
          one, then S is symmetric tri-diagonal.
          Not modified.
  A       DOUBLE PRECISION array, dimension (LDA , N)
          The original (unfactored) matrix.  It is assumed to be
          symmetric, and only the upper (UPLO='U') or only the lower
          (UPLO='L') will be referenced.
          Not modified.
  LDA     INTEGER
          The leading dimension of A.  It must be at least 1
          and at least N.
          Not modified.
  D       DOUBLE PRECISION array, dimension (N)
          The diagonal of the (symmetric tri-) diagonal matrix.
          Not modified.
  E       DOUBLE PRECISION array, dimension (N)
          The 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       DOUBLE PRECISION array, dimension (LDU, N)
          If ITYPE=1 or 3, this contains the orthogonal matrix in
          the decomposition, expressed as a dense matrix.  If ITYPE=2,
          then it is not referenced.
          Not modified.
  LDU     INTEGER
          The leading dimension of U.  LDU must be at least N and
          at least 1.
          Not modified.
  V       DOUBLE PRECISION array, dimension (LDV, N)
          If ITYPE=2 or 3, the lower triangle of this array contains
          the Householder vectors used to describe the orthogonal
          matrix in the decomposition.  If ITYPE=1, then it is not
          referenced.
          Not modified.
  LDV     INTEGER
          The leading dimension of V.  LDV must be at least N and
          at least 1.
          Not modified.
  TAU     DOUBLE PRECISION array, dimension (N)
          If ITYPE >= 2, then TAU(j) is the scalar factor of
          v(j) v(j)' in the Householder transformation H(j) of
          the product  U = H(1)...H(n-2)
          If ITYPE < 2, then TAU is not referenced.
          Not modified.
  WORK    DOUBLE PRECISION array, dimension (2*N**2)
          Workspace.
          Modified.
  RESULT  DOUBLE PRECISION array, dimension (2)
          The values computed by the two tests described above.  The
          values are currently limited to 1/ulp, to avoid overflow.
          RESULT(1) is always modified.  RESULT(2) is modified only
          if LDU is at least N.
          Modified.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine sbdt04 (character UPLO, integer N, real, dimension( * ) D, real, dimension( * ) E, real, dimension( * ) S, integer NS, real, dimension( ldu, * ) U, integer LDU, real, dimension( ldvt, * ) VT, integer LDVT, real, dimension( * ) WORK, real RESID)

Purpose:

SBDT04 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.

The test ratio to test the singular value decomposition is RESID = norm( S - U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix B is upper or lower bidiagonal.
          = 'U':  Upper bidiagonal
          = 'L':  Lower bidiagonal


N

          N is INTEGER
          The order of the matrix B.


D

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


E

          E is REAL 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'.


S

          S is REAL array, dimension (NS)
          The singular values from the (partial) SVD of B, sorted in 
          decreasing order.


NS

          NS is INTEGER
          The number of singular values/vectors from the (partial) 
          SVD of B.


U

          U is REAL array, dimension (LDU,NS)
          The n by ns orthogonal matrix U in S = U' * B * V.


LDU

          LDU is INTEGER
          The leading dimension of the array U.  LDU >= max(1,N)


VT

          VT is REAL array, dimension (LDVT,N)
          The n by ns orthogonal matrix V in S = U' * B * V.


LDVT

          LDVT is INTEGER
          The leading dimension of the array VT.


WORK

          WORK is REAL array, dimension (2*N)


RESID

          RESID is REAL
          The test ratio:  norm(S - U' * B * V) / ( n * norm(B) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine sbdt05 (integer M, integer N, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) S, integer NS, real, dimension( ldu, * ) U, integer LDU, real, dimension( ldvt, * ) VT, integer LDVT, real, dimension( * ) WORK, real RESID)

Purpose:

SBDT05 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.

The test ratio to test the singular value decomposition is RESID = norm( S - U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.

Parameters:

M

          M is INTEGER
          The number of rows of the matrices A and U.


N

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


A

          A is REAL array, dimension (LDA,N)
          The m by n matrix A.
 
aram[in] LDA leading dimension of the array A. LDA >= max(1,M).


S

          S is REAL array, dimension (NS)
          The singular values from the (partial) SVD of B, sorted in 
          decreasing order.


NS

          NS is INTEGER
          The number of singular values/vectors from the (partial) 
          SVD of B.


U

          U is REAL array, dimension (LDU,NS)
          The n by ns orthogonal matrix U in S = U' * B * V.


LDU

          LDU is INTEGER
          The leading dimension of the array U.  LDU >= max(1,N)


VT

          VT is REAL array, dimension (LDVT,N)
          The n by ns orthogonal matrix V in S = U' * B * V.


LDVT

          LDVT is INTEGER
          The leading dimension of the array VT.


WORK

          WORK is REAL array, dimension (M,N)


RESID

          RESID is REAL
          The test ratio:  norm(S - U' * A * V) / ( n * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zbdt05 (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) S, integer NS, complex*16, dimension( * ) U, integer LDU, complex*16, dimension( ldvt, * ) VT, integer LDVT, complex*16, dimension( * ) WORK, double precision RESID)

Purpose:

ZBDT05 reconstructs a bidiagonal matrix B from its (partial) SVD: S = U' * B * V where U and V are orthogonal matrices and S is diagonal.

The test ratio to test the singular value decomposition is RESID = norm( S - U' * B * V ) / ( n * norm(B) * EPS ) where VT = V' and EPS is the machine precision.

Parameters:

M

          M is INTEGER
          The number of rows of the matrices A and U.


N

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


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The m by n matrix A.
 
aram[in] LDA leading dimension of the array A. LDA >= max(1,M).


S

          S is DOUBLE PRECISION array, dimension (NS)
          The singular values from the (partial) SVD of B, sorted in 
          decreasing order.


NS

          NS is INTEGER
          The number of singular values/vectors from the (partial) 
          SVD of B.


U

          U is COMPLEX*16 array, dimension (LDU,NS)
          The n by ns orthogonal matrix U in S = U' * B * V.


LDU

          LDU is INTEGER
          The leading dimension of the array U.  LDU >= max(1,N)


VT

          VT is COMPLEX*16 array, dimension (LDVT,N)
          The n by ns orthogonal matrix V in S = U' * B * V.


LDVT

          LDVT is INTEGER
          The leading dimension of the array VT.


WORK

          WORK is COMPLEX*16 array, dimension (M,N)


RESID

          RESID is DOUBLE PRECISION
          The test ratio:  norm(S - U' * A * V) / ( n * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Author

Generated automatically by Doxygen for LAPACK from the source code.