zsgt01()

subroutine zsgt01	(	integer	itype,
		character	uplo,
		integer	n,
		integer	m,
		complex*16, dimension( lda, * )	a,
		integer	lda,
		complex*16, dimension( ldb, * )	b,
		integer	ldb,
		complex*16, dimension( ldz, * )	z,
		integer	ldz,
		double precision, dimension( * )	d,
		complex*16, dimension( * )	work,
		double precision, dimension( * )	rwork,
		double precision, dimension( * )	result
	)

ZSGT01

Purpose:

 CDGT01 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 Hermitian matrix, B is Hermitian positive definite,
 Z is unitary, 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

[in]	ITYPE	ITYPE is INTEGER The form of the Hermitian generalized eigenproblem. = 1: A*z = (lambda)*B*z = 2: A*B*z = (lambda)*z = 3: B*A*z = (lambda)*z
[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrices A and B is stored. = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The order of the matrix A. N >= 0.
[in]	M	M is INTEGER The number of eigenvalues found. M >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA, N) The original Hermitian matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in]	B	B is COMPLEX*16 array, dimension (LDB, N) The original Hermitian positive definite matrix B.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[in]	Z	Z is COMPLEX*16 array, dimension (LDZ, M) The computed eigenvectors of the generalized eigenproblem.
[in]	LDZ	LDZ is INTEGER The leading dimension of the array Z. LDZ >= max(1,N).
[in]	D	D is DOUBLE PRECISION array, dimension (M) The computed eigenvalues of the generalized eigenproblem.
[out]	WORK	WORK is COMPLEX*16 array, dimension (N*N)
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	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.

Definition at line 150 of file zsgt01.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 ..
      CHARACTER          UPLO
      INTEGER            ITYPE, LDA, LDB, LDZ, M, N
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   D( * ), RESULT( * ), RWORK( * )
      COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * ),
     $                   Z( LDZ, * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   ZERO, ONE
      parameter( zero = 0.0d+0, one = 1.0d+0 )
      COMPLEX*16         CZERO, CONE
      parameter( czero = ( 0.0d+0, 0.0d+0 ),
     $                   cone = ( 1.0d+0, 0.0d+0 ) )
*     ..
*     .. Local Scalars ..
      INTEGER            I
      DOUBLE PRECISION   ANORM, ULP
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DLAMCH, ZLANGE, ZLANHE
      EXTERNAL           dlamch, zlange, zlanhe
*     ..
*     .. External Subroutines ..
      EXTERNAL           zdscal, zhemm
*     ..
*     .. Executable Statements ..
*
      result( 1 ) = zero
      IF( n.LE.0 )
     $   RETURN
*
      ulp = dlamch( 'Epsilon' )
*
*     Compute product of 1-norms of A and Z.
*
      anorm = zlanhe( '1', uplo, n, a, lda, rwork )*
     $        zlange( '1', n, m, z, ldz, rwork )
      IF( anorm.EQ.zero )
     $   anorm = one
*
      IF( itype.EQ.1 ) THEN
*
*        Norm of AZ - BZD
*
         CALL zhemm( 'Left', uplo, n, m, cone, a, lda, z, ldz, czero,
     $               work, n )
         DO 10 i = 1, m
            CALL zdscal( n, d( i ), z( 1, i ), 1 )
   10    CONTINUE
         CALL zhemm( 'Left', uplo, n, m, cone, b, ldb, z, ldz, -cone,
     $               work, n )
*
         result( 1 ) = ( zlange( '1', n, m, work, n, rwork ) / anorm ) /
     $                 ( n*ulp )
*
      ELSE IF( itype.EQ.2 ) THEN
*
*        Norm of ABZ - ZD
*
         CALL zhemm( 'Left', uplo, n, m, cone, b, ldb, z, ldz, czero,
     $               work, n )
         DO 20 i = 1, m
            CALL zdscal( n, d( i ), z( 1, i ), 1 )
   20    CONTINUE
         CALL zhemm( 'Left', uplo, n, m, cone, a, lda, work, n, -cone,
     $               z, ldz )
*
         result( 1 ) = ( zlange( '1', n, m, z, ldz, rwork ) / anorm ) /
     $                 ( n*ulp )
*
      ELSE IF( itype.EQ.3 ) THEN
*
*        Norm of BAZ - ZD
*
         CALL zhemm( 'Left', uplo, n, m, cone, a, lda, z, ldz, czero,
     $               work, n )
         DO 30 i = 1, m
            CALL zdscal( n, d( i ), z( 1, i ), 1 )
   30    CONTINUE
         CALL zhemm( 'Left', uplo, n, m, cone, b, ldb, work, n, -cone,
     $               z, ldz )
*
         result( 1 ) = ( zlange( '1', n, m, z, ldz, rwork ) / anorm ) /
     $                 ( n*ulp )
      END IF
*
      RETURN
*
*     End of ZDGT01
*

Here is the call graph for this function:

Here is the caller graph for this function: