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 
!> of its elements is 1, where in this case, 
!> of a complex value x is  |Re(x)| + |Im(x)| ; let us call this
!> maximum  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.

Definition at line 159 of file cget52.f.

*
*  -- LAPACK test routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. 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, ldb, 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, abs( 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: