LAPACK  3.10.1
LAPACK: Linear Algebra PACKage

◆ chpgvd()

subroutine chpgvd ( integer  ITYPE,
character  JOBZ,
character  UPLO,
integer  N,
complex, dimension( * )  AP,
complex, dimension( * )  BP,
real, dimension( * )  W,
complex, dimension( ldz, * )  Z,
integer  LDZ,
complex, dimension( * )  WORK,
integer  LWORK,
real, dimension( * )  RWORK,
integer  LRWORK,
integer, dimension( * )  IWORK,
integer  LIWORK,
integer  INFO 
)

CHPGVD

Download CHPGVD + dependencies [TGZ] [ZIP] [TXT]

Purpose:
 CHPGVD computes all the eigenvalues and, optionally, the 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, stored in packed format, and B is also
 positive definite.
 If eigenvectors are desired, it uses a divide and conquer algorithm.

 The divide and conquer algorithm makes very mild assumptions about
 floating point arithmetic. It will work on machines with a guard
 digit in add/subtract, or on those binary machines without guard
 digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or
 Cray-2. It could conceivably fail on hexadecimal or decimal machines
 without guard digits, but we know of none.
Parameters
[in]ITYPE
          ITYPE is INTEGER
          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
[in]JOBZ
          JOBZ is CHARACTER*1
          = 'N':  Compute eigenvalues only;
          = 'V':  Compute eigenvalues and eigenvectors.
[in]UPLO
          UPLO is CHARACTER*1
          = 'U':  Upper triangles of A and B are stored;
          = 'L':  Lower triangles of A and B are stored.
[in]N
          N is INTEGER
          The order of the matrices A and B.  N >= 0.
[in,out]AP
          AP is COMPLEX array, dimension (N*(N+1)/2)
          On entry, the upper or lower triangle of the Hermitian matrix
          A, packed columnwise in a linear array.  The j-th column of A
          is stored in the array AP as follows:
          if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
          if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.

          On exit, the contents of AP are destroyed.
[in,out]BP
          BP is COMPLEX array, dimension (N*(N+1)/2)
          On entry, the upper or lower triangle of the Hermitian matrix
          B, packed columnwise in a linear array.  The j-th column of B
          is stored in the array BP as follows:
          if UPLO = 'U', BP(i + (j-1)*j/2) = B(i,j) for 1<=i<=j;
          if UPLO = 'L', BP(i + (j-1)*(2*n-j)/2) = B(i,j) for j<=i<=n.

          On exit, the triangular factor U or L from the Cholesky
          factorization B = U**H*U or B = L*L**H, in the same storage
          format as B.
[out]W
          W is REAL array, dimension (N)
          If INFO = 0, the eigenvalues in ascending order.
[out]Z
          Z is COMPLEX array, dimension (LDZ, N)
          If JOBZ = 'V', then if INFO = 0, Z contains the matrix Z of
          eigenvectors.  The eigenvectors are normalized as follows:
          if ITYPE = 1 or 2, Z**H*B*Z = I;
          if ITYPE = 3, Z**H*inv(B)*Z = I.
          If JOBZ = 'N', then Z is not referenced.
[in]LDZ
          LDZ is INTEGER
          The leading dimension of the array Z.  LDZ >= 1, and if
          JOBZ = 'V', LDZ >= max(1,N).
[out]WORK
          WORK is COMPLEX array, dimension (MAX(1,LWORK))
          On exit, if INFO = 0, WORK(1) returns the required LWORK.
[in]LWORK
          LWORK is INTEGER
          The dimension of array WORK.
          If N <= 1,               LWORK >= 1.
          If JOBZ = 'N' and N > 1, LWORK >= N.
          If JOBZ = 'V' and N > 1, LWORK >= 2*N.

          If LWORK = -1, then a workspace query is assumed; the routine
          only calculates the required 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.
[out]RWORK
          RWORK is REAL array, dimension (MAX(1,LRWORK))
          On exit, if INFO = 0, RWORK(1) returns the required LRWORK.
[in]LRWORK
          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 required 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.
[out]IWORK
          IWORK is INTEGER array, dimension (MAX(1,LIWORK))
          On exit, if INFO = 0, IWORK(1) returns the required LIWORK.
[in]LIWORK
          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 required 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.
[out]INFO
          INFO is INTEGER
          = 0:  successful exit
          < 0:  if INFO = -i, the i-th argument had an illegal value
          > 0:  CPPTRF or CHPEVD returned an error code:
             <= N:  if INFO = i, CHPEVD failed to converge;
                    i off-diagonal elements of an intermediate
                    tridiagonal form did not convergeto zero;
             > N:   if INFO = N + i, for 1 <= i <= n, then the leading
                    minor of order i of B is not positive definite.
                    The factorization of B could not be completed and
                    no eigenvalues or eigenvectors were computed.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Contributors:
Mark Fahey, Department of Mathematics, Univ. of Kentucky, USA

Definition at line 229 of file chpgvd.f.

231 *
232 * -- LAPACK driver routine --
233 * -- LAPACK is a software package provided by Univ. of Tennessee, --
234 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
235 *
236 * .. Scalar Arguments ..
237  CHARACTER JOBZ, UPLO
238  INTEGER INFO, ITYPE, LDZ, LIWORK, LRWORK, LWORK, N
239 * ..
240 * .. Array Arguments ..
241  INTEGER IWORK( * )
242  REAL RWORK( * ), W( * )
243  COMPLEX AP( * ), BP( * ), WORK( * ), Z( LDZ, * )
244 * ..
245 *
246 * =====================================================================
247 *
248 * .. Local Scalars ..
249  LOGICAL LQUERY, UPPER, WANTZ
250  CHARACTER TRANS
251  INTEGER J, LIWMIN, LRWMIN, LWMIN, NEIG
252 * ..
253 * .. External Functions ..
254  LOGICAL LSAME
255  EXTERNAL lsame
256 * ..
257 * .. External Subroutines ..
258  EXTERNAL chpevd, chpgst, cpptrf, ctpmv, ctpsv, xerbla
259 * ..
260 * .. Intrinsic Functions ..
261  INTRINSIC max, real
262 * ..
263 * .. Executable Statements ..
264 *
265 * Test the input parameters.
266 *
267  wantz = lsame( jobz, 'V' )
268  upper = lsame( uplo, 'U' )
269  lquery = ( lwork.EQ.-1 .OR. lrwork.EQ.-1 .OR. liwork.EQ.-1 )
270 *
271  info = 0
272  IF( itype.LT.1 .OR. itype.GT.3 ) THEN
273  info = -1
274  ELSE IF( .NOT.( wantz .OR. lsame( jobz, 'N' ) ) ) THEN
275  info = -2
276  ELSE IF( .NOT.( upper .OR. lsame( uplo, 'L' ) ) ) THEN
277  info = -3
278  ELSE IF( n.LT.0 ) THEN
279  info = -4
280  ELSE IF( ldz.LT.1 .OR. ( wantz .AND. ldz.LT.n ) ) THEN
281  info = -9
282  END IF
283 *
284  IF( info.EQ.0 ) THEN
285  IF( n.LE.1 ) THEN
286  lwmin = 1
287  liwmin = 1
288  lrwmin = 1
289  ELSE
290  IF( wantz ) THEN
291  lwmin = 2*n
292  lrwmin = 1 + 5*n + 2*n**2
293  liwmin = 3 + 5*n
294  ELSE
295  lwmin = n
296  lrwmin = n
297  liwmin = 1
298  END IF
299  END IF
300 *
301  work( 1 ) = lwmin
302  rwork( 1 ) = lrwmin
303  iwork( 1 ) = liwmin
304  IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
305  info = -11
306  ELSE IF( lrwork.LT.lrwmin .AND. .NOT.lquery ) THEN
307  info = -13
308  ELSE IF( liwork.LT.liwmin .AND. .NOT.lquery ) THEN
309  info = -15
310  END IF
311  END IF
312 *
313  IF( info.NE.0 ) THEN
314  CALL xerbla( 'CHPGVD', -info )
315  RETURN
316  ELSE IF( lquery ) THEN
317  RETURN
318  END IF
319 *
320 * Quick return if possible
321 *
322  IF( n.EQ.0 )
323  $ RETURN
324 *
325 * Form a Cholesky factorization of B.
326 *
327  CALL cpptrf( uplo, n, bp, info )
328  IF( info.NE.0 ) THEN
329  info = n + info
330  RETURN
331  END IF
332 *
333 * Transform problem to standard eigenvalue problem and solve.
334 *
335  CALL chpgst( itype, uplo, n, ap, bp, info )
336  CALL chpevd( jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork,
337  $ lrwork, iwork, liwork, info )
338  lwmin = max( real( lwmin ), real( work( 1 ) ) )
339  lrwmin = max( real( lrwmin ), real( rwork( 1 ) ) )
340  liwmin = max( real( liwmin ), real( iwork( 1 ) ) )
341 *
342  IF( wantz ) THEN
343 *
344 * Backtransform eigenvectors to the original problem.
345 *
346  neig = n
347  IF( info.GT.0 )
348  $ neig = info - 1
349  IF( itype.EQ.1 .OR. itype.EQ.2 ) THEN
350 *
351 * For A*x=(lambda)*B*x and A*B*x=(lambda)*x;
352 * backtransform eigenvectors: x = inv(L)**H *y or inv(U)*y
353 *
354  IF( upper ) THEN
355  trans = 'N'
356  ELSE
357  trans = 'C'
358  END IF
359 *
360  DO 10 j = 1, neig
361  CALL ctpsv( uplo, trans, 'Non-unit', n, bp, z( 1, j ),
362  $ 1 )
363  10 CONTINUE
364 *
365  ELSE IF( itype.EQ.3 ) THEN
366 *
367 * For B*A*x=(lambda)*x;
368 * backtransform eigenvectors: x = L*y or U**H *y
369 *
370  IF( upper ) THEN
371  trans = 'C'
372  ELSE
373  trans = 'N'
374  END IF
375 *
376  DO 20 j = 1, neig
377  CALL ctpmv( uplo, trans, 'Non-unit', n, bp, z( 1, j ),
378  $ 1 )
379  20 CONTINUE
380  END IF
381  END IF
382 *
383  work( 1 ) = lwmin
384  rwork( 1 ) = lrwmin
385  iwork( 1 ) = liwmin
386  RETURN
387 *
388 * End of CHPGVD
389 *
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine ctpsv(UPLO, TRANS, DIAG, N, AP, X, INCX)
CTPSV
Definition: ctpsv.f:144
subroutine ctpmv(UPLO, TRANS, DIAG, N, AP, X, INCX)
CTPMV
Definition: ctpmv.f:142
subroutine cpptrf(UPLO, N, AP, INFO)
CPPTRF
Definition: cpptrf.f:119
subroutine chpgst(ITYPE, UPLO, N, AP, BP, INFO)
CHPGST
Definition: chpgst.f:113
subroutine chpevd(JOBZ, UPLO, N, AP, W, Z, LDZ, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO)
CHPEVD computes the eigenvalues and, optionally, the left and/or right eigenvectors for OTHER matrice...
Definition: chpevd.f:200
Here is the call graph for this function:
Here is the caller graph for this function: