SRC/dsyev_2stage.f(3)

📦
version 3.12.1 · 7 versions
, in arch rolling

💜 SRC/dsyev_2stage.f 💜

okay so bestie, welcome to dsyev_2stage — this is the LAPACK manual page for it, and I'm gonna walk you through every single bit, no cap. it's giving ✨serious linear algebra✨ but make it cute.

🌸 NAME 🌸

SRC/dsyev_2stage.f — yes that's literally the name, it's a Fortran source file page and we love her for it 💅

✨ SYNOPSIS ✨

Functions/Subroutines

  • subroutine dsyev_2stage (jobz, uplo, n, a, lda, w, work, lwork, info) — DSYEV_2STAGE computes the eigenvalues and, optionally, the left and/or right eigenvectors for SY matrices 🦋

🎀 Function/Subroutine Documentation 🎀

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 🔥

💫 Purpose:

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

so like, it finds all the eigenvalues (and maybe the eigenvectors if you ask nicely) of a real symmetric matrix A, and it does it with the 2stage technique for the reduction to tridiagonal. iconic. 👑

🫶 Parameters 🫶

  • JOBZ — it's a CHARACTER*1, bestie. here's the tea:
!>          JOBZ is CHARACTER*1
!>          = 'N':  Compute eigenvalues only;
!>          = 'V':  Compute eigenvalues and eigenvectors.
!>                  Not available in this release.
!>
⚠️ heads up: 'V' is not available in this release — so don't come for me when it doesn't work, okay? 😭
  • UPLO — also CHARACTER*1, telling us which triangle is the moment:
!>          UPLO is CHARACTER*1
!>          = 'U':  Upper triangle of A is stored;
!>          = 'L':  Lower triangle of A is stored.
!>
  • N — an INTEGER, the order of the matrix A, and N >= 0. that's it, that's the vibe check 🌈
!>          N is INTEGER
!>          The order of the matrix A.  N >= 0.
!>
  • A — a DOUBLE PRECISION array, dimension (LDA, N). here's the whole story:
!>          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.
!>
💀 read that last part again — with JOBZ = 'N', the triangle you fed in (plus the diagonal!) gets destroyed on exit. she does not survive. protect your data accordingly.
  • LDA — INTEGER, the leading dimension of the array A, and LDA >= max(1,N).
!>          LDA is INTEGER
!>          The leading dimension of the array A.  LDA >= max(1,N).
!>
  • W — DOUBLE PRECISION array, dimension (N). if INFO = 0, you get the eigenvalues in ascending order. sorted, slay 🍓
!>          W is DOUBLE PRECISION array, dimension (N)
!>          If INFO = 0, the eigenvalues in ascending order.
!>
  • WORK — DOUBLE PRECISION array, dimension (MAX(1,LWORK)). on exit, if INFO = 0, then WORK(1) returns the optimal LWORK 👑
!>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
!>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
!>
  • LWORK — INTEGER, the length of the array WORK. okay this one's the main character and she has LORE:
!>          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.
!>
🌟 so real talk: LWORK >= 1 when N <= 1; otherwise, if JOBZ = 'N' and N > 1, you must query LWORK. and if JOBZ = 'V' and N > 1, you must query too — but that's not yet available. also: LWORK = -1 means a workspace query, where the routine only calculates the optimal size of WORK, returns it as the first entry of WORK, and XERBLA issues no error message about LWORK. iykyk 💅
  • INFO — INTEGER, the receipts:
!>          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.

the whole squad ate, fr fr 🫶

🧚 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
!>
!>

like, the full bibliography is right there — go read the papers if you wanna know everything about the 2stage technique, bestie 📚✨

Definition at line 181 of file dsyev_2stage.f.

💖 sign-off 💖

this page was Generated automatically by Doxygen for LAPACK from the source code — so nobody hand-wrote it, it just appeared, main character energy honestly.

and the footer tea: LAPACK, Version 3.12.0, from SRC/dsyev_2stage.f(3). periodt. 💅🎀🦋

📦 where this page comes from