subroutine chet21	(	integer	ITYPE,
		character	UPLO,
		integer	N,
		integer	KBAND,
		complex, dimension( lda, * )	A,
		integer	LDA,
		real, dimension( * )	D,
		real, dimension( * )	E,
		complex, dimension( ldu, * )	U,
		integer	LDU,
		complex, dimension( ldv, * )	V,
		integer	LDV,
		complex, dimension( * )	TAU,
		complex, dimension( * )	WORK,
		real, dimension( * )	RWORK,
		real, dimension( 2 )	RESULT
	)

CHET21

Purpose:

 CHET21 generally checks a decomposition of the form

    A = U S UC>
 where * means conjugate transpose, A is hermitian, U is unitary, and
 S is diagonal (if KBAND=0) or (real) symmetric tridiagonal (if
 KBAND=1).

 If ITYPE=1, then U is represented as a dense matrix; otherwise U is
 expressed as a product of Householder transformations, whose vectors
 are stored in the array "V" and whose scaling constants are in "TAU".
 We shall use the letter "V" to refer to the product of Householder
 transformations (which should be equal to U).

 Specifically, if ITYPE=1, then:

    RESULT(1) = | A - U S U* | / ( |A| n ulp ) *andC>    RESULT(2) = | I - UU* | / ( n ulp )

 If ITYPE=2, then:

    RESULT(1) = | A - V S V* | / ( |A| n ulp )

 If ITYPE=3, then:

    RESULT(1) = | I - UV* | / ( n ulp )

 For ITYPE > 1, the transformation U is expressed as a product
 V = H(1)...H(n-2),  where H(j) = I  -  tau(j) v(j) v(j)C> and each
 vector v(j) has its first j elements 0 and the remaining n-j elements
 stored in V(j+1:n,j).

Parameters

[in]	ITYPE	ITYPE is INTEGER Specifies the type of tests to be performed. 1: U expressed as a dense unitary matrix: RESULT(1) = | A - U S U* | / ( |A| n ulp ) *andC> RESULT(2) = | I - UU* | / ( n ulp ) 2: U expressed as a product V of Housholder transformations: RESULT(1) = | A - V S V* | / ( |A| n ulp ) 3: U expressed both as a dense unitary matrix and as a product of Housholder transformations: RESULT(1) = | I - UV* | / ( n ulp )
[in]	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.
[in]	N	N is INTEGER The size of the matrix. If it is zero, CHET21 does nothing. It must be at least zero.
[in]	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.
[in]	A	A is COMPLEX array, dimension (LDA, N) The original (unfactored) matrix. It is assumed to be hermitian, and only the upper (UPLO='U') or only the lower (UPLO='L') will be referenced.
[in]	LDA	LDA is INTEGER The leading dimension of A. It must be at least 1 and at least N.
[in]	D	D is REAL array, dimension (N) The diagonal of the (symmetric tri-) diagonal matrix.
[in]	E	E is REAL 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.
[in]	U	U is COMPLEX array, dimension (LDU, N) If ITYPE=1 or 3, this contains the unitary matrix in the decomposition, expressed as a dense matrix. If ITYPE=2, then it is not referenced.
[in]	LDU	LDU is INTEGER The leading dimension of U. LDU must be at least N and at least 1.
[in]	V	V is COMPLEX array, dimension (LDV, N) If ITYPE=2 or 3, the columns of this array contain the Householder vectors used to describe the unitary matrix in the decomposition. If UPLO='L', then the vectors are in the lower triangle, if UPLO='U', then in the upper triangle. *NOTE* If ITYPE=2 or 3, V is modified and restored. The subdiagonal (if UPLO='L') or the superdiagonal (if UPLO='U') is set to one, and later reset to its original value, during the course of the calculation. If ITYPE=1, then it is neither referenced nor modified.
[in]	LDV	LDV is INTEGER The leading dimension of V. LDV must be at least N and at least 1.
[in]	TAU	TAU is COMPLEX 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.
[out]	WORK	WORK is COMPLEX array, dimension (2*N**2)
[out]	RWORK	RWORK is REAL array, dimension (N)
[out]	RESULT	RESULT is REAL 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

Definition at line 213 of file chet21.f.

*
*  -- 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          uplo
      INTEGER            itype, kband, lda, ldu, ldv, n
*     ..
*     .. Array Arguments ..
      REAL               d( * ), e( * ), result( 2 ), rwork( * )
      COMPLEX            a( lda, * ), tau( * ), u( ldu, * ),
     $                   v( ldv, * ), work( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               zero, one, ten
      parameter                ( zero = 0.0e+0, one = 1.0e+0, ten = 10.0e+0 )
      COMPLEX            czero, cone
      parameter                ( czero = ( 0.0e+0, 0.0e+0 ),
     $                   cone = ( 1.0e+0, 0.0e+0 ) )
*     ..
*     .. Local Scalars ..
      LOGICAL            lower
      CHARACTER          cuplo
      INTEGER            iinfo, j, jcol, jr, jrow
      REAL               anorm, ulp, unfl, wnorm
      COMPLEX            vsave
*     ..
*     .. External Functions ..
      LOGICAL            lsame
      REAL               clange, clanhe, slamch
      EXTERNAL           lsame, clange, clanhe, slamch
*     ..
*     .. External Subroutines ..
      EXTERNAL           cgemm, cher, cher2, clacpy, clarfy, claset,
     $                   cunm2l, cunm2r
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          cmplx, max, min, real
*     ..
*     .. Executable Statements ..
*
      result( 1 ) = zero
      IF( itype.EQ.1 )
     $   result( 2 ) = zero
      IF( n.LE.0 )
     $   RETURN
*
      IF( lsame( uplo, 'U' ) ) THEN
         lower = .false.
         cuplo = 'U'
      ELSE
         lower = .true.
         cuplo = 'L'
      END IF
*
      unfl = slamch( 'Safe minimum' )
      ulp = slamch( 'Epsilon' )*slamch( 'Base' )
*
*     Some Error Checks
*
      IF( itype.LT.1 .OR. itype.GT.3 ) THEN
         result( 1 ) = ten / ulp
         RETURN
      END IF
*
*     Do Test 1
*
*     Norm of A:
*
      IF( itype.EQ.3 ) THEN
         anorm = one
      ELSE
         anorm = max( clanhe( '1', cuplo, n, a, lda, rwork ), unfl )
      END IF
*
*     Compute error matrix:
*
      IF( itype.EQ.1 ) THEN
*
*        ITYPE=1: error = A - U S U*
*
         CALL claset( 'Full', n, n, czero, czero, work, n )
         CALL clacpy( cuplo, n, n, a, lda, work, n )
*
         DO 10 j = 1, n
            CALL cher( cuplo, n, -d( j ), u( 1, j ), 1, work, n )
   10    CONTINUE
*
         IF( n.GT.1 .AND. kband.EQ.1 ) THEN
            DO 20 j = 1, n - 1
               CALL cher2( cuplo, n, -cmplx( e( j ) ), u( 1, j ), 1,
     $                     u( 1, j-1 ), 1, work, n )
   20       CONTINUE
         END IF
         wnorm = clanhe( '1', cuplo, n, work, n, rwork )
*
      ELSE IF( itype.EQ.2 ) THEN
*
*        ITYPE=2: error = V S V* - A
*
         CALL claset( 'Full', n, n, czero, czero, work, n )
*
         IF( lower ) THEN
            work( n**2 ) = d( n )
            DO 40 j = n - 1, 1, -1
               IF( kband.EQ.1 ) THEN
                  work( ( n+1 )*( j-1 )+2 ) = ( cone-tau( j ) )*e( j )
                  DO 30 jr = j + 2, n
                     work( ( j-1 )*n+jr ) = -tau( j )*e( j )*v( jr, j )
   30             CONTINUE
               END IF
*
               vsave = v( j+1, j )
               v( j+1, j ) = one
               CALL clarfy( 'L', n-j, v( j+1, j ), 1, tau( j ),
     $                      work( ( n+1 )*j+1 ), n, work( n**2+1 ) )
               v( j+1, j ) = vsave
               work( ( n+1 )*( j-1 )+1 ) = d( j )
   40       CONTINUE
         ELSE
            work( 1 ) = d( 1 )
            DO 60 j = 1, n - 1
               IF( kband.EQ.1 ) THEN
                  work( ( n+1 )*j ) = ( cone-tau( j ) )*e( j )
                  DO 50 jr = 1, j - 1
                     work( j*n+jr ) = -tau( j )*e( j )*v( jr, j+1 )
   50             CONTINUE
               END IF
*
               vsave = v( j, j+1 )
               v( j, j+1 ) = one
               CALL clarfy( 'U', j, v( 1, j+1 ), 1, tau( j ), work, n,
     $                      work( n**2+1 ) )
               v( j, j+1 ) = vsave
               work( ( n+1 )*j+1 ) = d( j+1 )
   60       CONTINUE
         END IF
*
         DO 90 jcol = 1, n
            IF( lower ) THEN
               DO 70 jrow = jcol, n
                  work( jrow+n*( jcol-1 ) ) = work( jrow+n*( jcol-1 ) )
     $                - a( jrow, jcol )
   70          CONTINUE
            ELSE
               DO 80 jrow = 1, jcol
                  work( jrow+n*( jcol-1 ) ) = work( jrow+n*( jcol-1 ) )
     $                - a( jrow, jcol )
   80          CONTINUE
            END IF
   90    CONTINUE
         wnorm = clanhe( '1', cuplo, n, work, n, rwork )
*
      ELSE IF( itype.EQ.3 ) THEN
*
*        ITYPE=3: error = U V* - I
*
         IF( n.LT.2 )
     $      RETURN
         CALL clacpy( ' ', n, n, u, ldu, work, n )
         IF( lower ) THEN
            CALL cunm2r( 'R', 'C', n, n-1, n-1, v( 2, 1 ), ldv, tau,
     $                   work( n+1 ), n, work( n**2+1 ), iinfo )
         ELSE
            CALL cunm2l( 'R', 'C', n, n-1, n-1, v( 1, 2 ), ldv, tau,
     $                   work, n, work( n**2+1 ), iinfo )
         END IF
         IF( iinfo.NE.0 ) THEN
            result( 1 ) = ten / ulp
            RETURN
         END IF
*
         DO 100 j = 1, n
            work( ( n+1 )*( j-1 )+1 ) = work( ( n+1 )*( j-1 )+1 ) - cone
  100    CONTINUE
*
         wnorm = clange( '1', n, n, work, n, rwork )
      END IF
*
      IF( anorm.GT.wnorm ) THEN
         result( 1 ) = ( wnorm / anorm ) / ( n*ulp )
      ELSE
         IF( anorm.LT.one ) THEN
            result( 1 ) = ( min( wnorm, n*anorm ) / anorm ) / ( n*ulp )
         ELSE
            result( 1 ) = min( wnorm / anorm, REAL( N ) ) / ( n*ulp )
         END IF
      END IF
*
*     Do Test 2
*
*     Compute  UU* - I
*
      IF( itype.EQ.1 ) THEN
         CALL cgemm( 'N', 'C', n, n, n, cone, u, ldu, u, ldu, czero,
     $               work, n )
*
         DO 110 j = 1, n
            work( ( n+1 )*( j-1 )+1 ) = work( ( n+1 )*( j-1 )+1 ) - cone
  110    CONTINUE
*
         result( 2 ) = min( clange( '1', n, n, work, n, rwork ),
     $                 REAL( N ) ) / ( n*ulp )
      END IF
*
      RETURN
*
*     End of CHET21
*

Here is the call graph for this function:

Here is the caller graph for this function: