dget22.f

Go to the documentation of this file.

*> \brief \b DGET22
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at 
*            http://www.netlib.org/lapack/explore-html/ 
*
*  Definition:
*  ===========
*
*       SUBROUTINE DGET22( TRANSA, TRANSE, TRANSW, N, A, LDA, E, LDE, WR,
*                          WI, WORK, RESULT )
* 
*       .. Scalar Arguments ..
*       CHARACTER          TRANSA, TRANSE, TRANSW
*       INTEGER            LDA, LDE, N
*       ..
*       .. Array Arguments ..
*       DOUBLE PRECISION   A( LDA, * ), E( LDE, * ), RESULT( 2 ), WI( * ),
*      $                   WORK( * ), WR( * )
*       ..
*  
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> 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.
*> \endverbatim
*
*  Arguments:
*  ==========
*
*> \param[in] TRANSA
*> \verbatim
*>          TRANSA is CHARACTER*1
*>          Specifies whether or not A is transposed.
*>          = 'N':  No transpose
*>          = 'T':  Transpose
*>          = 'C':  Conjugate transpose (= Transpose)
*> \endverbatim
*>
*> \param[in] TRANSE
*> \verbatim
*>          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)
*> \endverbatim
*>
*> \param[in] TRANSW
*> \verbatim
*>          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)
*> \endverbatim
*>
*> \param[in] N
*> \verbatim
*>          N is INTEGER
*>          The order of the matrix A.  N >= 0.
*> \endverbatim
*>
*> \param[in] A
*> \verbatim
*>          A is DOUBLE PRECISION array, dimension (LDA,N)
*>          The matrix whose eigenvectors are in E.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*>          LDA is INTEGER
*>          The leading dimension of the array A.  LDA >= max(1,N).
*> \endverbatim
*>
*> \param[in] E
*> \verbatim
*>          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.
*> \endverbatim
*>
*> \param[in] LDE
*> \verbatim
*>          LDE is INTEGER
*>          The leading dimension of the array E.  LDE >= max(1,N).
*> \endverbatim
*>
*> \param[in] WR
*> \verbatim
*>          WR is DOUBLE PRECISION array, dimension (N)
*> \endverbatim
*>
*> \param[in] WI
*> \verbatim
*>          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.
*> \endverbatim
*>
*> \param[out] WORK
*> \verbatim
*>          WORK is DOUBLE PRECISION array, dimension (N*(N+1))
*> \endverbatim
*>
*> \param[out] RESULT
*> \verbatim
*>          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 )
*> \endverbatim
*
*  Authors:
*  ========
*
*> \author Univ. of Tennessee 
*> \author Univ. of California Berkeley 
*> \author Univ. of Colorado Denver 
*> \author NAG Ltd. 
*
*> \date November 2011
*
*> \ingroup double_eig
*
*  =====================================================================
      SUBROUTINE dget22( TRANSA, TRANSE, TRANSW, N, A, LDA, E, LDE, WR,
     $                   wi, work, result )
*
*  -- LAPACK test routine (version 3.4.0) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     November 2011
*
*     .. Scalar Arguments ..
      CHARACTER          transa, transe, transw
      INTEGER            lda, lde, n
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   a( lda, * ), e( lde, * ), result( 2 ), wi( * ),
     $                   work( * ), wr( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   zero, one
      parameter( zero = 0.0d0, one = 1.0d0 )
*     ..
*     .. Local Scalars ..
      CHARACTER          norma, norme
      INTEGER            iecol, ierow, ince, ipair, itrnse, j, jcol,
     $                   jvec
      DOUBLE PRECISION   anorm, enorm, enrmax, enrmin, errnrm, temp1,
     $                   ulp, unfl
*     ..
*     .. Local Arrays ..
      DOUBLE PRECISION   wmat( 2, 2 )
*     ..
*     .. External Functions ..
      LOGICAL            lsame
      DOUBLE PRECISION   dlamch, dlange
      EXTERNAL           lsame, dlamch, dlange
*     ..
*     .. External Subroutines ..
      EXTERNAL           daxpy, dgemm, dlaset
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, dble, max, min
*     ..
*     .. Executable Statements ..
*
*     Initialize RESULT (in case N=0)
*
      result( 1 ) = zero
      result( 2 ) = zero
      IF( n.LE.0 )
     $   return
*
      unfl = dlamch( 'Safe minimum' )
      ulp = dlamch( 'Precision' )
*
      itrnse = 0
      ince = 1
      norma = 'O'
      norme = 'O'
*
      IF( lsame( transa, 'T' ) .OR. lsame( transa, 'C' ) ) THEN
         norma = 'I'
      END IF
      IF( lsame( transe, 'T' ) .OR. lsame( transe, 'C' ) ) THEN
         norme = 'I'
         itrnse = 1
         ince = lde
      END IF
*
*     Check normalization of E
*
      enrmin = one / ulp
      enrmax = zero
      IF( itrnse.EQ.0 ) THEN
*
*        Eigenvectors are column vectors.
*
         ipair = 0
         DO 30 jvec = 1, n
            temp1 = zero
            IF( ipair.EQ.0 .AND. jvec.LT.n .AND. wi( jvec ).NE.zero )
     $         ipair = 1
            IF( ipair.EQ.1 ) THEN
*
*              Complex eigenvector
*
               DO 10 j = 1, n
                  temp1 = max( temp1, abs( e( j, jvec ) )+
     $                    abs( e( j, jvec+1 ) ) )
   10          continue
               enrmin = min( enrmin, temp1 )
               enrmax = max( enrmax, temp1 )
               ipair = 2
            ELSE IF( ipair.EQ.2 ) THEN
               ipair = 0
            ELSE
*
*              Real eigenvector
*
               DO 20 j = 1, n
                  temp1 = max( temp1, abs( e( j, jvec ) ) )
   20          continue
               enrmin = min( enrmin, temp1 )
               enrmax = max( enrmax, temp1 )
               ipair = 0
            END IF
   30    continue
*
      ELSE
*
*        Eigenvectors are row vectors.
*
         DO 40 jvec = 1, n
            work( jvec ) = zero
   40    continue
*
         DO 60 j = 1, n
            ipair = 0
            DO 50 jvec = 1, n
               IF( ipair.EQ.0 .AND. jvec.LT.n .AND. wi( jvec ).NE.zero )
     $            ipair = 1
               IF( ipair.EQ.1 ) THEN
                  work( jvec ) = max( work( jvec ),
     $                           abs( e( j, jvec ) )+abs( e( j,
     $                           jvec+1 ) ) )
                  work( jvec+1 ) = work( jvec )
               ELSE IF( ipair.EQ.2 ) THEN
                  ipair = 0
               ELSE
                  work( jvec ) = max( work( jvec ),
     $                           abs( e( j, jvec ) ) )
                  ipair = 0
               END IF
   50       continue
   60    continue
*
         DO 70 jvec = 1, n
            enrmin = min( enrmin, work( jvec ) )
            enrmax = max( enrmax, work( jvec ) )
   70    continue
      END IF
*
*     Norm of A:
*
      anorm = max( dlange( norma, n, n, a, lda, work ), unfl )
*
*     Norm of E:
*
      enorm = max( dlange( norme, n, n, e, lde, work ), ulp )
*
*     Norm of error:
*
*     Error =  AE - EW
*
      CALL dlaset( 'Full', n, n, zero, zero, work, n )
*
      ipair = 0
      ierow = 1
      iecol = 1
*
      DO 80 jcol = 1, n
         IF( itrnse.EQ.1 ) THEN
            ierow = jcol
         ELSE
            iecol = jcol
         END IF
*
         IF( ipair.EQ.0 .AND. wi( jcol ).NE.zero )
     $      ipair = 1
*
         IF( ipair.EQ.1 ) THEN
            wmat( 1, 1 ) = wr( jcol )
            wmat( 2, 1 ) = -wi( jcol )
            wmat( 1, 2 ) = wi( jcol )
            wmat( 2, 2 ) = wr( jcol )
            CALL dgemm( transe, transw, n, 2, 2, one, e( ierow, iecol ),
     $                  lde, wmat, 2, zero, work( n*( jcol-1 )+1 ), n )
            ipair = 2
         ELSE IF( ipair.EQ.2 ) THEN
            ipair = 0
*
         ELSE
*
            CALL daxpy( n, wr( jcol ), e( ierow, iecol ), ince,
     $                  work( n*( jcol-1 )+1 ), 1 )
            ipair = 0
         END IF
*
   80 continue
*
      CALL dgemm( transa, transe, n, n, n, one, a, lda, e, lde, -one,
     $            work, n )
*
      errnrm = dlange( 'One', n, n, work, n, work( n*n+1 ) ) / enorm
*
*     Compute RESULT(1) (avoiding under/overflow)
*
      IF( anorm.GT.errnrm ) THEN
         result( 1 ) = ( errnrm / anorm ) / ulp
      ELSE
         IF( anorm.LT.one ) THEN
            result( 1 ) = ( min( errnrm, anorm ) / anorm ) / ulp
         ELSE
            result( 1 ) = min( errnrm / anorm, one ) / ulp
         END IF
      END IF
*
*     Compute RESULT(2) : the normalization error in E.
*
      result( 2 ) = max( abs( enrmax-one ), abs( enrmin-one ) ) /
     $              ( dble( n )*ulp )
*
      return
*
*     End of DGET22
*
      END