Go to main content
Oracle Developer Studio 12.5 Man Pages

Exit Print View

Updated: June 2017
 
 

zhegvx (3p)

Name

zhegvx - compute selected eigenvalues, and optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x

Synopsis

SUBROUTINE ZHEGVX(ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB, VL,
VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK, IWORK,
IFAIL, INFO)

CHARACTER*1 JOBZ, RANGE, UPLO
DOUBLE COMPLEX A(LDA,*), B(LDB,*), Z(LDZ,*), WORK(*)
INTEGER ITYPE, N, LDA, LDB, IL, IU, M, LDZ, LWORK, INFO
INTEGER IWORK(*), IFAIL(*)
DOUBLE PRECISION VL, VU, ABSTOL
DOUBLE PRECISION W(*), RWORK(*)

SUBROUTINE ZHEGVX_64(ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB, VL,
VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK, IWORK,
IFAIL, INFO)

CHARACTER*1 JOBZ, RANGE, UPLO
DOUBLE COMPLEX A(LDA,*), B(LDB,*), Z(LDZ,*), WORK(*)
INTEGER*8 ITYPE, N, LDA, LDB, IL, IU, M, LDZ, LWORK, INFO
INTEGER*8 IWORK(*), IFAIL(*)
DOUBLE PRECISION VL, VU, ABSTOL
DOUBLE PRECISION W(*), RWORK(*)




F95 INTERFACE
SUBROUTINE HEGVX(ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB,
VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK,
IWORK, IFAIL, INFO)

CHARACTER(LEN=1) :: JOBZ, RANGE, UPLO
COMPLEX(8), DIMENSION(:) :: WORK
COMPLEX(8), DIMENSION(:,:) :: A, B, Z
INTEGER :: ITYPE, N, LDA, LDB, IL, IU, M, LDZ, LWORK, INFO
INTEGER, DIMENSION(:) :: IWORK, IFAIL
REAL(8) :: VL, VU, ABSTOL
REAL(8), DIMENSION(:) :: W, RWORK

SUBROUTINE HEGVX_64(ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB,
VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK,
IWORK, IFAIL, INFO)

CHARACTER(LEN=1) :: JOBZ, RANGE, UPLO
COMPLEX(8), DIMENSION(:) :: WORK
COMPLEX(8), DIMENSION(:,:) :: A, B, Z
INTEGER(8) :: ITYPE, N, LDA, LDB, IL, IU, M, LDZ, LWORK, INFO
INTEGER(8), DIMENSION(:) :: IWORK, IFAIL
REAL(8) :: VL, VU, ABSTOL
REAL(8), DIMENSION(:) :: W, RWORK




C INTERFACE
#include <sunperf.h>

void zhegvx(int itype, char jobz, char range, char uplo, int n, double-
complex *a, int lda, doublecomplex *b, int  ldb,  double  vl,
double  vu, int il, int iu, double abstol, int *m, double *w,
doublecomplex *z, int ldz, int *ifail, int *info);

void zhegvx_64(long itype, char jobz, char range, char  uplo,  long  n,
doublecomplex  *a, long lda, doublecomplex *b, long ldb, dou-
ble vl, double vu, long il, long iu, double abstol, long  *m,
double  *w,  doublecomplex  *z,  long  ldz, long *ifail, long
*info);

Description

Oracle Solaris Studio Performance Library                           zhegvx(3P)



NAME
       zhegvx  - compute selected eigenvalues, and optionally, eigenvectors of
       a complex generalized  Hermitian-definite  eigenproblem,  of  the  form
       A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x


SYNOPSIS
       SUBROUTINE ZHEGVX(ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB, VL,
             VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK, IWORK,
             IFAIL, INFO)

       CHARACTER*1 JOBZ, RANGE, UPLO
       DOUBLE COMPLEX A(LDA,*), B(LDB,*), Z(LDZ,*), WORK(*)
       INTEGER ITYPE, N, LDA, LDB, IL, IU, M, LDZ, LWORK, INFO
       INTEGER IWORK(*), IFAIL(*)
       DOUBLE PRECISION VL, VU, ABSTOL
       DOUBLE PRECISION W(*), RWORK(*)

       SUBROUTINE ZHEGVX_64(ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB, VL,
             VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK, IWORK,
             IFAIL, INFO)

       CHARACTER*1 JOBZ, RANGE, UPLO
       DOUBLE COMPLEX A(LDA,*), B(LDB,*), Z(LDZ,*), WORK(*)
       INTEGER*8 ITYPE, N, LDA, LDB, IL, IU, M, LDZ, LWORK, INFO
       INTEGER*8 IWORK(*), IFAIL(*)
       DOUBLE PRECISION VL, VU, ABSTOL
       DOUBLE PRECISION W(*), RWORK(*)




   F95 INTERFACE
       SUBROUTINE HEGVX(ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB,
              VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK,
              IWORK, IFAIL, INFO)

       CHARACTER(LEN=1) :: JOBZ, RANGE, UPLO
       COMPLEX(8), DIMENSION(:) :: WORK
       COMPLEX(8), DIMENSION(:,:) :: A, B, Z
       INTEGER :: ITYPE, N, LDA, LDB, IL, IU, M, LDZ, LWORK, INFO
       INTEGER, DIMENSION(:) :: IWORK, IFAIL
       REAL(8) :: VL, VU, ABSTOL
       REAL(8), DIMENSION(:) :: W, RWORK

       SUBROUTINE HEGVX_64(ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB,
              VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, LWORK, RWORK,
              IWORK, IFAIL, INFO)

       CHARACTER(LEN=1) :: JOBZ, RANGE, UPLO
       COMPLEX(8), DIMENSION(:) :: WORK
       COMPLEX(8), DIMENSION(:,:) :: A, B, Z
       INTEGER(8) :: ITYPE, N, LDA, LDB, IL, IU, M, LDZ, LWORK, INFO
       INTEGER(8), DIMENSION(:) :: IWORK, IFAIL
       REAL(8) :: VL, VU, ABSTOL
       REAL(8), DIMENSION(:) :: W, RWORK




   C INTERFACE
       #include <sunperf.h>

       void zhegvx(int itype, char jobz, char range, char uplo, int n, double-
                 complex *a, int lda, doublecomplex *b, int  ldb,  double  vl,
                 double  vu, int il, int iu, double abstol, int *m, double *w,
                 doublecomplex *z, int ldz, int *ifail, int *info);

       void zhegvx_64(long itype, char jobz, char range, char  uplo,  long  n,
                 doublecomplex  *a, long lda, doublecomplex *b, long ldb, dou-
                 ble vl, double vu, long il, long iu, double abstol, long  *m,
                 double  *w,  doublecomplex  *z,  long  ldz, long *ifail, long
                 *info);



PURPOSE
       zhegvx computes selected eigenvalues, and optionally, eigenvectors of a
       complex   generalized  Hermitian-definite  eigenproblem,  of  the  form
       A*x=(lambda)*B*x,  A*Bx=(lambda)*x,  or B*A*x=(lambda)*x.  Here A and B
       are assumed to be Hermitian and B is also positive definite.  Eigenval-
       ues and eigenvectors can be selected by specifying either  a  range  of
       values or a range of indices for the desired eigenvalues.


ARGUMENTS
       ITYPE (input)
                 Specifies the problem type to be solved:
                 = 1:  A*x = (lambda)*B*x
                 = 2:  A*B*x = (lambda)*x
                 = 3:  B*A*x = (lambda)*x


       JOBZ (input)
                 = 'N':  Compute eigenvalues only;
                 = 'V':  Compute eigenvalues and eigenvectors.


       RANGE (input)
                 = 'A': all eigenvalues will be found.
                 = 'V': all eigenvalues in the half-open interval (VL,VU] will
                 be found.  = 'I': the IL-th through IU-th eigenvalues will be
                 found.


       UPLO (input)
                 = 'U':  Upper triangles of A and B are stored;
                 = 'L':  Lower triangles of A and B are stored.


       N (input) The order of the matrices A and B.  N >= 0.


       A (input/output)
                 On entry, the Hermitian matrix A.  If UPLO = 'U', the leading
                 N-by-N upper triangular part of A contains the upper triangu-
                 lar  part of the matrix A.  If UPLO = 'L', the leading N-by-N
                 lower triangular part of A contains the lower triangular part
                 of the matrix A.

                 On  exit,  the lower triangle (if UPLO='L') or the upper tri-
                 angle  (if  UPLO='U')  of  A,  including  the  diagonal,   is
                 destroyed.


       LDA (input)
                 The leading dimension of the array A.  LDA >= max(1,N).


       B (input/output)
                 On entry, the Hermitian matrix B.  If UPLO = 'U', the leading
                 N-by-N upper triangular part of B contains the upper triangu-
                 lar  part of the matrix B.  If UPLO = 'L', the leading N-by-N
                 lower triangular part of B contains the lower triangular part
                 of the matrix B.

                 On exit, if INFO <= N, the part of B containing the matrix is
                 overwritten by the triangular factor U or L from the Cholesky
                 factorization B = U**H*U or B = L*L**H.


       LDB (input)
                 The leading dimension of the array B.  LDB >= max(1,N).


       VL (input)
                 If  RANGE='V',  the lower and upper bounds of the interval to
                 be searched for eigenvalues. VL  <  VU.   Not  referenced  if
                 RANGE = 'A' or 'I'.


       VU (input)
                 If  RANGE='V',  the lower and upper bounds of the interval to
                 be searched for eigenvalues. VL  <  VU.   Not  referenced  if
                 RANGE = 'A' or 'I'.


       IL (input)
                 If  RANGE='I', the indices (in ascending order) of the small-
                 est and largest eigenvalues to be returned.  1 <= IL <= IU <=
                 N,  if  N > 0; IL = 1 and IU = 0 if N = 0.  Not referenced if
                 RANGE = 'A' or 'V'.


       IU (input)
                 If RANGE='I', the indices (in ascending order) of the  small-
                 est and largest eigenvalues to be returned.  1 <= IL <= IU <=
                 N, if N > 0; IL = 1 and IU = 0 if N = 0.  Not  referenced  if
                 RANGE = 'A' or 'V'.


       ABSTOL (input)
                 The absolute error tolerance for the eigenvalues.  An approx-
                 imate eigenvalue is accepted as converged when it  is  deter-
                 mined to lie in an interval [a,b] of width less than or equal
                 to

                 ABSTOL + EPS *   max( |a|,|b| ) ,

                 where EPS is the machine precision.  If ABSTOL is  less  than
                 or  equal  to zero, then  EPS*|T|  will be used in its place,
                 where |T| is the 1-norm of the tridiagonal matrix obtained by
                 reducing A to tridiagonal form.

                 Eigenvalues  will  be computed most accurately when ABSTOL is
                 set to twice the underflow threshold 2*DLAMCH('S'), not zero.
                 If  this  routine  returns  with INFO>0, indicating that some
                 eigenvectors  did  not  converge,  try  setting   ABSTOL   to
                 2*DLAMCH('S').


       M (output)
                 The  total  number  of  eigenvalues  found.  0 <= M <= N.  If
                 RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1.


       W (output)
                 The first M elements  contain  the  selected  eigenvalues  in
                 ascending order.


       Z (output)
                 If JOBZ = 'N', then Z is not referenced.  If JOBZ = 'V', then
                 if INFO = 0, the first M columns of Z contain the orthonormal
                 eigenvectors  of  the  matrix A corresponding to the selected
                 eigenvalues, with the i-th column of Z holding the  eigenvec-
                 tor associated with W(i).  The eigenvectors are normalized as
                 follows: if ITYPE = 1 or 2, Z**T*B*Z  =  I;  if  ITYPE  =  3,
                 Z**T*inv(B)*Z = I.

                 If  an  eigenvector  fails to converge, then that column of Z
                 contains the latest approximation to the eigenvector, and the
                 index  of  the  eigenvector  is returned in IFAIL.  Note: the
                 user must ensure that at least max(1,M) columns are  supplied
                 in  the  array Z; if RANGE = 'V', the exact value of M is not
                 known in advance and an upper bound must be used.


       LDZ (input)
                 The leading dimension of the array Z.  LDZ >= 1, and if  JOBZ
                 = 'V', LDZ >= max(1,N).


       WORK (workspace/output)
                 On exit, if INFO = 0, WORK(1) returns the optimal LWORK.


       LWORK (input)
                 The  length  of  the  array  WORK.  LWORK >= max(1,2*N).  For
                 optimal efficiency, LWORK >= (NB+1)*N, where NB is the block-
                 size for ZHETRD returned by ILAENV.

                 If LWORK = -1, then a workspace query is assumed; the routine
                 only calculates the optimal size of the WORK  array,  returns
                 this value as the first entry of the WORK array, and no error
                 message related to LWORK is issued by XERBLA.


       RWORK (workspace)
                 dimension(7*N)

       IWORK (workspace)
                 dimension(5*N)

       IFAIL (output)
                 If JOBZ = 'V', then if INFO = 0,  the  first  M  elements  of
                 IFAIL are zero.  If INFO > 0, then IFAIL contains the indices
                 of the eigenvectors that failed to converge.  If JOBZ =  'N',
                 then IFAIL is not referenced.


       INFO (output)
                 = 0:  successful exit
                 < 0:  if INFO = -i, the i-th argument had an illegal value
                 > 0:  CPOTRF or ZHEEVX returned an error code:
                 <= N:  if INFO = i, ZHEEVX failed to converge; i eigenvectors
                 failed to converge.  Their indices are stored in array IFAIL.
                 >  N:    if  INFO  = N + i, for 1 <= i <= N, then the leading
                 minor of order i of B is not positive definite.  The  factor-
                 ization  of  B  could  not be completed and no eigenvalues or
                 eigenvectors were computed.

FURTHER DETAILS
       Based on contributions by
          Mark Fahey, Department of Mathematics, Univ. of Kentucky, USA




                                  7 Nov 2015                        zhegvx(3P)