dc/d7b/zhbgvd_8f_source.html

*> \brief \b ZHBGVD

*

*  =========== DOCUMENTATION ===========

*

* Online html documentation available at

*            http://www.netlib.org/lapack/explore-html/

*

*> \htmlonly

*> Download ZHBGVD + dependencies

*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zhbgvd.f">

*> [TGZ]</a>

*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zhbgvd.f">

*> [ZIP]</a>

*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbgvd.f">

*> [TXT]</a>

*> \endhtmlonly

*

*  Definition:

*  ===========

*

*       SUBROUTINE ZHBGVD( JOBZ, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, W,

*                          Z, LDZ, WORK, LWORK, RWORK, LRWORK, IWORK,

*                          LIWORK, INFO )

*

*       .. Scalar Arguments ..

*       CHARACTER          JOBZ, UPLO

*       INTEGER            INFO, KA, KB, LDAB, LDBB, LDZ, LIWORK, LRWORK,

*      $                   LWORK, N

*       ..

*       .. Array Arguments ..

*       INTEGER            IWORK( * )

*       DOUBLE PRECISION   RWORK( * ), W( * )

*       COMPLEX*16         AB( LDAB, * ), BB( LDBB, * ), WORK( * ),

*      $                   Z( LDZ, * )

*       ..

*

*

*> \par Purpose:

*  =============

*>

*> \verbatim

*>

*> ZHBGVD computes all the eigenvalues, and optionally, the eigenvectors

*> of a complex generalized Hermitian-definite banded eigenproblem, of

*> the form A*x=(lambda)*B*x. Here A and B are assumed to be Hermitian

*> and banded, and B is also positive definite.  If eigenvectors are

*> desired, it uses a divide and conquer algorithm.

*>

*> \endverbatim

*

*  Arguments:

*  ==========

*

*> \param[in] JOBZ

*> \verbatim

*>          JOBZ is CHARACTER*1

*>          = 'N':  Compute eigenvalues only;

*>          = 'V':  Compute eigenvalues and eigenvectors.

*> \endverbatim

*>

*> \param[in] UPLO

*> \verbatim

*>          UPLO is CHARACTER*1

*>          = 'U':  Upper triangles of A and B are stored;

*>          = 'L':  Lower triangles of A and B are stored.

*> \endverbatim

*>

*> \param[in] N

*> \verbatim

*>          N is INTEGER

*>          The order of the matrices A and B.  N >= 0.

*> \endverbatim

*>

*> \param[in] KA

*> \verbatim

*>          KA is INTEGER

*>          The number of superdiagonals of the matrix A if UPLO = 'U',

*>          or the number of subdiagonals if UPLO = 'L'. KA >= 0.

*> \endverbatim

*>

*> \param[in] KB

*> \verbatim

*>          KB is INTEGER

*>          The number of superdiagonals of the matrix B if UPLO = 'U',

*>          or the number of subdiagonals if UPLO = 'L'. KB >= 0.

*> \endverbatim

*>

*> \param[in,out] AB

*> \verbatim

*>          AB is COMPLEX*16 array, dimension (LDAB, N)

*>          On entry, the upper or lower triangle of the Hermitian band

*>          matrix A, stored in the first ka+1 rows of the array.  The

*>          j-th column of A is stored in the j-th column of the array AB

*>          as follows:

*>          if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;

*>          if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).

*>

*>          On exit, the contents of AB are destroyed.

*> \endverbatim

*>

*> \param[in] LDAB

*> \verbatim

*>          LDAB is INTEGER

*>          The leading dimension of the array AB.  LDAB >= KA+1.

*> \endverbatim

*>

*> \param[in,out] BB

*> \verbatim

*>          BB is COMPLEX*16 array, dimension (LDBB, N)

*>          On entry, the upper or lower triangle of the Hermitian band

*>          matrix B, stored in the first kb+1 rows of the array.  The

*>          j-th column of B is stored in the j-th column of the array BB

*>          as follows:

*>          if UPLO = 'U', BB(kb+1+i-j,j) = B(i,j) for max(1,j-kb)<=i<=j;

*>          if UPLO = 'L', BB(1+i-j,j)    = B(i,j) for j<=i<=min(n,j+kb).

*>

*>          On exit, the factor S from the split Cholesky factorization

*>          B = S**H*S, as returned by ZPBSTF.

*> \endverbatim

*>

*> \param[in] LDBB

*> \verbatim

*>          LDBB is INTEGER

*>          The leading dimension of the array BB.  LDBB >= KB+1.

*> \endverbatim

*>

*> \param[out] W

*> \verbatim

*>          W is DOUBLE PRECISION array, dimension (N)

*>          If INFO = 0, the eigenvalues in ascending order.

*> \endverbatim

*>

*> \param[out] Z

*> \verbatim

*>          Z is COMPLEX*16 array, dimension (LDZ, N)

*>          If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of

*>          eigenvectors, with the i-th column of Z holding the

*>          eigenvector associated with W(i). The eigenvectors are

*>          normalized so that Z**H*B*Z = I.

*>          If JOBZ = 'N', then Z is not referenced.

*> \endverbatim

*>

*> \param[in] LDZ

*> \verbatim

*>          LDZ is INTEGER

*>          The leading dimension of the array Z.  LDZ >= 1, and if

*>          JOBZ = 'V', LDZ >= N.

*> \endverbatim

*>

*> \param[out] WORK

*> \verbatim

*>          WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))

*>          On exit, if INFO=0, WORK(1) returns the optimal LWORK.

*> \endverbatim

*>

*> \param[in] LWORK

*> \verbatim

*>          LWORK is INTEGER

*>          The dimension of the array WORK.

*>          If N <= 1,               LWORK >= 1.

*>          If JOBZ = 'N' and N > 1, LWORK >= N.

*>          If JOBZ = 'V' and N > 1, LWORK >= 2*N**2.

*>

*>          If LWORK = -1, then a workspace query is assumed; the routine

*>          only calculates the optimal sizes of the WORK, RWORK and

*>          IWORK arrays, returns these values as the first entries of

*>          the WORK, RWORK and IWORK arrays, and no error message

*>          related to LWORK or LRWORK or LIWORK is issued by XERBLA.

*> \endverbatim

*>

*> \param[out] RWORK

*> \verbatim

*>          RWORK is DOUBLE PRECISION array, dimension (MAX(1,LRWORK))

*>          On exit, if INFO=0, RWORK(1) returns the optimal LRWORK.

*> \endverbatim

*>

*> \param[in] LRWORK

*> \verbatim

*>          LRWORK is INTEGER

*>          The dimension of array RWORK.

*>          If N <= 1,               LRWORK >= 1.

*>          If JOBZ = 'N' and N > 1, LRWORK >= N.

*>          If JOBZ = 'V' and N > 1, LRWORK >= 1 + 5*N + 2*N**2.

*>

*>          If LRWORK = -1, then a workspace query is assumed; the

*>          routine only calculates the optimal sizes of the WORK, RWORK

*>          and IWORK arrays, returns these values as the first entries

*>          of the WORK, RWORK and IWORK arrays, and no error message

*>          related to LWORK or LRWORK or LIWORK is issued by XERBLA.

*> \endverbatim

*>

*> \param[out] IWORK

*> \verbatim

*>          IWORK is INTEGER array, dimension (MAX(1,LIWORK))

*>          On exit, if INFO=0, IWORK(1) returns the optimal LIWORK.

*> \endverbatim

*>

*> \param[in] LIWORK

*> \verbatim

*>          LIWORK is INTEGER

*>          The dimension of array IWORK.

*>          If JOBZ = 'N' or N <= 1, LIWORK >= 1.

*>          If JOBZ = 'V' and N > 1, LIWORK >= 3 + 5*N.

*>

*>          If LIWORK = -1, then a workspace query is assumed; the

*>          routine only calculates the optimal sizes of the WORK, RWORK

*>          and IWORK arrays, returns these values as the first entries

*>          of the WORK, RWORK and IWORK arrays, and no error message

*>          related to LWORK or LRWORK or LIWORK is issued by XERBLA.

*> \endverbatim

*>

*> \param[out] INFO

*> \verbatim

*>          INFO is INTEGER

*>          = 0:  successful exit

*>          < 0:  if INFO = -i, the i-th argument had an illegal value

*>          > 0:  if INFO = i, and i is:

*>             <= N:  the algorithm failed to converge:

*>                    i off-diagonal elements of an intermediate

*>                    tridiagonal form did not converge to zero;

*>             > N:   if INFO = N + i, for 1 <= i <= N, then ZPBSTF

*>                    returned INFO = i: B is not positive definite.

*>                    The factorization of B could not be completed and

*>                    no eigenvalues or eigenvectors were computed.

*> \endverbatim

*

*  Authors:

*  ========

*

*> \author Univ. of Tennessee

*> \author Univ. of California Berkeley

*> \author Univ. of Colorado Denver

*> \author NAG Ltd.

*

*> \ingroup hbgvd

*

*> \par Contributors:

*  ==================

*>

*>     Mark Fahey, Department of Mathematics, Univ. of Kentucky, USA

*

*  =====================================================================

      SUBROUTINE zhbgvd( JOBZ, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, W,

     $                   Z, LDZ, WORK, LWORK, RWORK, LRWORK, IWORK,

     $                   LIWORK, INFO )

*

*  -- LAPACK driver 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          JOBZ, UPLO

      INTEGER            INFO, KA, KB, LDAB, LDBB, LDZ, LIWORK, LRWORK,

     $                   lwork, n

*     ..

*     .. Array Arguments ..

      INTEGER            IWORK( * )

      DOUBLE PRECISION   RWORK( * ), W( * )

      COMPLEX*16         AB( LDAB, * ), BB( LDBB, * ), WORK( * ),

     $                   z( ldz, * )

*     ..

*

*  =====================================================================

*

*     .. Parameters ..

      COMPLEX*16         CONE, CZERO

      PARAMETER          ( CONE = ( 1.0d+0, 0.0d+0 ),

     $                   czero = ( 0.0d+0, 0.0d+0 ) )

*     ..

*     .. Local Scalars ..

      LOGICAL            LQUERY, UPPER, WANTZ

      CHARACTER          VECT

      INTEGER            IINFO, INDE, INDWK2, INDWRK, LIWMIN, LLRWK,

     $                   llwk2, lrwmin, lwmin

*     ..

*     .. External Functions ..

      LOGICAL            LSAME

      EXTERNAL           LSAME

*     ..

*     .. External Subroutines ..

      EXTERNAL           dsterf, xerbla, zgemm, zhbgst, zhbtrd, zlacpy,

     $                   zpbstf, zstedc

*     ..

*     .. Executable Statements ..

*

*     Test the input parameters.

*

      wantz = lsame( jobz, 'V' )

      upper = lsame( uplo, 'U' )

      lquery = ( lwork.EQ.-1 .OR. lrwork.EQ.-1 .OR. liwork.EQ.-1 )

*

      info = 0

      IF( n.LE.1 ) THEN

         lwmin = 1+n

         lrwmin = 1+n

         liwmin = 1

      ELSE IF( wantz ) THEN

         lwmin = 2*n**2

         lrwmin = 1 + 5*n + 2*n**2

         liwmin = 3 + 5*n

      ELSE

         lwmin = n

         lrwmin = n

         liwmin = 1

      END IF

      IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN

         info = -1

      ELSE IF( .NOT.( upper .OR. lsame( uplo, 'L' ) ) ) THEN

         info = -2

      ELSE IF( n.LT.0 ) THEN

         info = -3

      ELSE IF( ka.LT.0 ) THEN

         info = -4

      ELSE IF( kb.LT.0 .OR. kb.GT.ka ) THEN

         info = -5

      ELSE IF( ldab.LT.ka+1 ) THEN

         info = -7

      ELSE IF( ldbb.LT.kb+1 ) THEN

         info = -9

      ELSE IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) ) THEN

         info = -12

      END IF

*

      IF( info.EQ.0 ) THEN

         work( 1 ) = lwmin

         rwork( 1 ) = lrwmin

         iwork( 1 ) = liwmin

*

         IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN

            info = -14

         ELSE IF( lrwork.LT.lrwmin .AND. .NOT.lquery ) THEN

            info = -16

         ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery ) THEN

            info = -18

         END IF

      END IF

*

      IF( info.NE.0 ) THEN

         CALL xerbla( 'ZHBGVD', -info )

         RETURN

      ELSE IF( lquery ) THEN

         RETURN

      END IF

*

*     Quick return if possible

*

      IF( n.EQ.0 )

     $   RETURN

*

*     Form a split Cholesky factorization of B.

*

      CALL zpbstf( uplo, n, kb, bb, ldbb, info )

      IF( info.NE.0 ) THEN

         info = n + info

         RETURN

      END IF

*

*     Transform problem to standard eigenvalue problem.

*

      inde = 1

      indwrk = inde + n

      indwk2 = 1 + n*n

      llwk2 = lwork - indwk2 + 2

      llrwk = lrwork - indwrk + 2

      CALL zhbgst( jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, z, ldz,

     $             work, rwork, iinfo )

*

*     Reduce Hermitian band matrix to tridiagonal form.

*

      IF( wantz ) THEN

         vect = 'U'

      ELSE

         vect = 'N'

      END IF

      CALL zhbtrd( vect, uplo, n, ka, ab, ldab, w, rwork( inde ), z,

     $             ldz, work, iinfo )

*

*     For eigenvalues only, call DSTERF.  For eigenvectors, call ZSTEDC.

*

      IF( .NOT.wantz ) THEN

         CALL dsterf( n, w, rwork( inde ), info )

      ELSE

         CALL zstedc( 'I', n, w, rwork( inde ), work, n, work( indwk2 ),

     $                llwk2, rwork( indwrk ), llrwk, iwork, liwork,

     $                info )

         CALL zgemm( 'N', 'N', n, n, n, cone, z, ldz, work, n, czero,

     $               work( indwk2 ), n )

         CALL zlacpy( 'A', n, n, work( indwk2 ), n, z, ldz )

      END IF

*

      work( 1 ) = lwmin

      rwork( 1 ) = lrwmin

      iwork( 1 ) = liwmin

      RETURN

*

*     End of ZHBGVD

*

      END

xerbla
subroutine xerbla(srname, info)
Definition cblat2.f:3285

zgemm
subroutine zgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
ZGEMM
Definition zgemm.f:188

zhbgst
subroutine zhbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info)
ZHBGST
Definition zhbgst.f:165

zhbgvd
subroutine zhbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
ZHBGVD
Definition zhbgvd.f:246

zhbtrd
subroutine zhbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info)
ZHBTRD
Definition zhbtrd.f:163

zlacpy
subroutine zlacpy(uplo, m, n, a, lda, b, ldb)
ZLACPY copies all or part of one two-dimensional array to another.
Definition zlacpy.f:103

zpbstf
subroutine zpbstf(uplo, n, kd, ab, ldab, info)
ZPBSTF
Definition zpbstf.f:153

zstedc
subroutine zstedc(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info)
ZSTEDC
Definition zstedc.f:206

dsterf
subroutine dsterf(n, d, e, info)
DSTERF
Definition dsterf.f:86