Loading...
Searching...
No Matches

## dsyev_2stage()

subroutine dsyev_2stage | ( | character | jobz,
|  | character | uplo,
|  | integer | n,
|  | double precision, dimension( lda, * ) | a,
|  | integer | lda,
|  | double precision, dimension( * ) | w,
|  | double precision, dimension( * ) | work,
|  | integer | lwork,
|  | integer | info )

DSYEV_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices

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

Purpose:

      !>
      !> DSYEV_2STAGE computes all eigenvalues and, optionally, eigenvectors of a
      !> real symmetric matrix A using the 2stage technique for
      !> the reduction to tridiagonal.
      !>

Parameters

  [in]

  JOBZ

      !>          JOBZ is CHARACTER*1
      !>          = 'N':  Compute eigenvalues only;
      !>          = 'V':  Compute eigenvalues and eigenvectors.
      !>                  Not available in this release.
      !>

  [in]

  UPLO

      !>          UPLO is CHARACTER*1
      !>          = 'U':  Upper triangle of A is stored;
      !>          = 'L':  Lower triangle of A is stored.
      !>

  [in]

  N

      !>          N is INTEGER
      !>          The order of the matrix A.  N >= 0.
      !>

  [in,out]

  A

      !>          A is DOUBLE PRECISION array, dimension (LDA, N)
      !>          On entry, the symmetric matrix A.  If UPLO = 'U', the
      !>          leading N-by-N upper triangular part of A contains the
      !>          upper triangular 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, if JOBZ = 'V', then if INFO = 0, A contains the
      !>          orthonormal eigenvectors of the matrix A.
      !>          If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')
      !>          or the upper triangle (if UPLO='U') of A, including the
      !>          diagonal, is destroyed.
      !>

  [in]

  LDA

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

  [out]

  W

      !>          W is DOUBLE PRECISION array, dimension (N)
      !>          If INFO = 0, the eigenvalues in ascending order.
      !>

  [out]

  WORK

      !>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
      !>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
      !>

  [in]

  LWORK

      !>          LWORK is INTEGER
      !>          The length of the array WORK. LWORK >= 1, when N <= 1;
      !>          otherwise
      !>          If JOBZ = 'N' and N > 1, LWORK must be queried.
      !>                                   LWORK = MAX(1, dimension) where
      !>                                   dimension = max(stage1,stage2) + (KD+1)*N + 2*N
      !>                                             = N*KD + N*max(KD+1,FACTOPTNB)
      !>                                               + max(2*KD*KD, KD*NTHREADS)
      !>                                               + (KD+1)*N + 2*N
      !>                                   where KD is the blocking size of the reduction,
      !>                                   FACTOPTNB is the blocking used by the QR or LQ
      !>                                   algorithm, usually FACTOPTNB=128 is a good choice
      !>                                   NTHREADS is the number of threads used when
      !>                                   openMP compilation is enabled, otherwise =1.
      !>          If JOBZ = 'V' and N > 1, LWORK must be queried. Not yet available
      !>
      !>          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.
      !>

  [out]

  INFO

      !>          INFO is INTEGER
      !>          = 0:  successful exit
      !>          < 0:  if INFO = -i, the i-th argument had an illegal value
      !>          > 0:  if INFO = i, the algorithm failed to converge; i
      !>                off-diagonal elements of an intermediate tridiagonal
      !>                form did not converge to zero.
      !>

Author
  Univ. of Tennessee
  Univ. of California Berkeley
  Univ. of Colorado Denver
  NAG Ltd.

Further Details:

      !>
      !>  All details about the 2stage techniques are available in:
      !>
      !>  Azzam Haidar, Hatem Ltaief, and Jack Dongarra.
      !>  Parallel reduction to condensed forms for symmetric eigenvalue problems
      !>  using aggregated fine-grained and memory-aware kernels. In Proceedings
      !>  of 2011 International Conference for High Performance Computing,
      !>  Networking, Storage and Analysis (SC '11), New York, NY, USA,
      !>  Article 8 , 11 pages.
      !>  http://doi.acm.org/10.1145/2063384.2063394
      !>
      !>  A. Haidar, J. Kurzak, P. Luszczek, 2013.
      !>  An improved parallel singular value algorithm and its implementation
      !>  for multicore hardware, In Proceedings of 2013 International Conference
      !>  for High Performance Computing, Networking, Storage and Analysis (SC '13).
      !>  Denver, Colorado, USA, 2013.
      !>  Article 90, 12 pages.
      !>  http://doi.acm.org/10.1145/2503210.2503292
      !>
      !>  A. Haidar, R. Solca, S. Tomov, T. Schulthess and J. Dongarra.
      !>  A novel hybrid CPU-GPU generalized eigensolver for electronic structure
      !>  calculations based on fine-grained memory aware tasks.
      !>  International Journal of High Performance Computing Applications.
      !>  Volume 28 Issue 2, Pages 196-209, May 2014.
      !>  http://hpc.sagepub.com/content/28/2/196
      !>
      !>