cget52()

subroutine cget52	(	logical	LEFT,
		integer	N,
		complex, dimension( lda, * )	A,
		integer	LDA,
		complex, dimension( ldb, * )	B,
		integer	LDB,
		complex, dimension( lde, * )	E,
		integer	LDE,
		complex, dimension( * )	ALPHA,
		complex, dimension( * )	BETA,
		complex, dimension( * )	WORK,
		real, dimension( * )	RWORK,
		real, dimension( 2 )	RESULT
	)

CGET52

Purpose:

 CGET52  does an eigenvector check for the generalized eigenvalue
 problem.

 The basic test for right eigenvectors is:

                           | b(i) A E(i) -  a(i) B E(i) |
         RESULT(1) = max   -------------------------------
                      i    n ulp max( |b(i) A|, |a(i) B| )

 using the 1-norm.  Here, a(i)/b(i) = w is the i-th generalized
 eigenvalue of A - w B, or, equivalently, b(i)/a(i) = m is the i-th
 generalized eigenvalue of m A - B.

                         H   H  _      _
 For left eigenvectors, A , B , a, and b  are used.

 CGET52 also tests the normalization of E.  Each eigenvector is
 supposed to be normalized so that the maximum "absolute value"
 of its elements is 1, where in this case, "absolute value"
 of a complex value x is  |Re(x)| + |Im(x)| ; let us call this
 maximum "absolute value" norm of a vector v  M(v).
 if a(i)=b(i)=0, then the eigenvector is set to be the jth coordinate
 vector. The normalization test is:

         RESULT(2) =      max       | M(v(i)) - 1 | / ( n ulp )
                    eigenvectors v(i)

Parameters

[in]	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.
[in]	N	N is INTEGER The size of the matrices. If it is zero, CGET52 does nothing. It must be at least zero.
[in]	A	A is COMPLEX array, dimension (LDA, N) The matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of A. It must be at least 1 and at least N.
[in]	B	B is COMPLEX array, dimension (LDB, N) The matrix B.
[in]	LDB	LDB is INTEGER The leading dimension of B. It must be at least 1 and at least N.
[in]	E	E is COMPLEX array, dimension (LDE, N) The matrix of eigenvectors. It must be O( 1 ).
[in]	LDE	LDE is INTEGER The leading dimension of E. It must be at least 1 and at least N.
[in]	ALPHA	ALPHA is COMPLEX array, dimension (N) The values a(i) as described above, which, along with b(i), define the generalized eigenvalues.
[in]	BETA	BETA is COMPLEX array, dimension (N) The values b(i) as described above, which, along with a(i), define the generalized eigenvalues.
[out]	WORK	WORK is COMPLEX array, dimension (N**2)
[out]	RWORK	RWORK is REAL array, dimension (N)
[out]	RESULT	RESULT is REAL 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

December 2016

Definition at line 163 of file cget52.f.

*
*  -- LAPACK test routine (version 3.7.0) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     December 2016
*
*     .. Scalar Arguments ..
      LOGICAL            LEFT
      INTEGER            LDA, LDB, LDE, N
*     ..
*     .. Array Arguments ..
      REAL               RESULT( 2 ), RWORK( * )
      COMPLEX            A( LDA, * ), ALPHA( * ), B( LDB, * ),
     $                   BETA( * ), E( LDE, * ), WORK( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               ZERO, ONE
      parameter( zero = 0.0e+0, one = 1.0e+0 )
      COMPLEX            CZERO, CONE
      parameter( czero = ( 0.0e+0, 0.0e+0 ),
     $                   cone = ( 1.0e+0, 0.0e+0 ) )
*     ..
*     .. Local Scalars ..
      CHARACTER          NORMAB, TRANS
      INTEGER            J, JVEC
      REAL               ABMAX, ALFMAX, ANORM, BETMAX, BNORM, ENORM,
     $                   ENRMER, ERRNRM, SAFMAX, SAFMIN, SCALE, TEMP1,
     $                   ULP
      COMPLEX            ACOEFF, ALPHAI, BCOEFF, BETAI, X
*     ..
*     .. External Functions ..
      REAL               CLANGE, SLAMCH
      EXTERNAL           clange, slamch
*     ..
*     .. External Subroutines ..
      EXTERNAL           cgemv
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, aimag, conjg, max, real
*     ..
*     .. Statement Functions ..
      REAL               ABS1
*     ..
*     .. Statement Function definitions ..
      abs1( x ) = abs( real( x ) ) + abs( aimag( x ) )
*     ..
*     .. Executable Statements ..
*
      result( 1 ) = zero
      result( 2 ) = zero
      IF( n.LE.0 )
     $   RETURN
*
      safmin = slamch( 'Safe minimum' )
      safmax = one / safmin
      ulp = slamch( 'Epsilon' )*slamch( 'Base' )
*
      IF( left ) THEN
         trans = 'C'
         normab = 'I'
      ELSE
         trans = 'N'
         normab = 'O'
      END IF
*
*     Norm of A, B, and E:
*
      anorm = max( clange( normab, n, n, a, lda, rwork ), safmin )
      bnorm = max( clange( normab, n, n, b, ldb, rwork ), safmin )
      enorm = max( clange( 'O', n, n, e, lde, rwork ), ulp )
      alfmax = safmax / max( one, bnorm )
      betmax = safmax / max( one, anorm )
*
*     Compute error matrix.
*     Column i = ( b(i) A - a(i) B ) E(i) / max( |a(i) B| |b(i) A| )
*
      DO 10 jvec = 1, n
         alphai = alpha( jvec )
         betai = beta( jvec )
         abmax = max( abs1( alphai ), abs1( betai ) )
         IF( abs1( alphai ).GT.alfmax .OR. abs1( betai ).GT.betmax .OR.
     $       abmax.LT.one ) THEN
            scale = one / max( abmax, safmin )
            alphai = scale*alphai
            betai = scale*betai
         END IF
         scale = one / max( abs1( alphai )*bnorm, abs1( betai )*anorm,
     $           safmin )
         acoeff = scale*betai
         bcoeff = scale*alphai
         IF( left ) THEN
            acoeff = conjg( acoeff )
            bcoeff = conjg( bcoeff )
         END IF
         CALL cgemv( trans, n, n, acoeff, a, lda, e( 1, jvec ), 1,
     $               czero, work( n*( jvec-1 )+1 ), 1 )
         CALL cgemv( trans, n, n, -bcoeff, b, lda, e( 1, jvec ), 1,
     $               cone, work( n*( jvec-1 )+1 ), 1 )
   10 CONTINUE
*
      errnrm = clange( 'One', n, n, work, n, rwork ) / enorm
*
*     Compute RESULT(1)
*
      result( 1 ) = errnrm / ulp
*
*     Normalization of E:
*
      enrmer = zero
      DO 30 jvec = 1, n
         temp1 = zero
         DO 20 j = 1, n
            temp1 = max( temp1, abs1( e( j, jvec ) ) )
   20    CONTINUE
         enrmer = max( enrmer, temp1-one )
   30 CONTINUE
*
*     Compute RESULT(2) : the normalization error in E.
*
      result( 2 ) = enrmer / ( real( n )*ulp )
*
      RETURN
*
*     End of CGET52
*

Here is the call graph for this function:

Here is the caller graph for this function: