SRC/chetrd_2stage.f(3)

📦

version 3.12.1 · 4 versions

3.12.1 · arch rolling (latest)
3.12.0 · opensuse-leap 16.0
3.9.0 · centos-stream 9
3.12.0 · centos-stream 10, fedora 43, fedora 44

💖 SRC/chetrd_2stage.f 💖

okay bestie, welcome to the LAPACK manual page for SRC/chetrd_2stage.f — yes that's the whole title, she's lowkey mysterious like that ✨

🌸 SYNOPSIS 🌸

Functions/Subroutines

subroutine chetrd_2stage (vect, uplo, n, a, lda, d, e, tau, hous2,
    lhous2, work, lwork, info)
    CHETRD_2STAGE

🦋 Function/Subroutine Documentation 🦋

subroutine chetrd_2stage (character vect, character uplo, integer n,
    complex, dimension( lda, * ) a, integer lda, real, dimension( * ) d,
    real, dimension( * ) e, complex, dimension( * ) tau, complex, dimension(
    * ) hous2, integer lhous2, complex, dimension( * ) work, integer lwork,
    integer info)

CHETRD_2STAGE — she's the main character, no cap 👑

🎀 Purpose

!>
!> CHETRD_2STAGE reduces a complex Hermitian matrix A to real symmetric
!> tridiagonal form T by a unitary similarity transformation:
!> Q1**H Q2**H* A * Q2 * Q1 = T.
!>

like, she takes your fancy complex Hermitian girlie A and turns her into a real symmetric tridiagonal T, using a unitary similarity transformation — and the whole vibe is Q1**H Q2**H* A * Q2 * Q1 = T. periodt 💅

✨ Parameters

VECT — VECT is CHARACTER*1:

!>          = 'N':  No need for the Housholder representation,
!>                  in particular for the second stage (Band to
!>                  tridiagonal) and thus LHOUS2 is of size max(1, 4*N);
!>          = 'V':  the Householder representation is needed to
!>                  either generate Q1 Q2 or to apply Q1 Q2,
!>                  then LHOUS2 is to be queried and computed.
!>                  (NOT AVAILABLE IN THIS RELEASE).
!>

🫶 heads up bestie: 'V' is literally NOT AVAILABLE IN THIS RELEASE. don't come for her.

UPLO — UPLO is CHARACTER*1:

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

N — N is INTEGER. The order of the matrix A. N >= 0. 🍓
A — A is COMPLEX array, dimension (LDA,N):

!>          On entry, the Hermitian matrix A.  If UPLO = 'U', the leading
!>          N-by-N upper triangular part of A contains the upper
!>          triangular part of the matrix A, and the strictly lower
!>          triangular part of A is not referenced.  If UPLO = 'L', the
!>          leading N-by-N lower triangular part of A contains the lower
!>          triangular part of the matrix A, and the strictly upper
!>          triangular part of A is not referenced.
!>          On exit, if UPLO = 'U', the band superdiagonal
!>          of A are overwritten by the corresponding elements of the
!>          internal band-diagonal matrix AB, and the elements above
!>          the KD superdiagonal, with the array TAU, represent the unitary
!>          matrix Q1 as a product of elementary reflectors; if UPLO
!>          = 'L', the diagonal and band subdiagonal of A are over-
!>          written by the corresponding elements of the internal band-diagonal
!>          matrix AB, and the elements below the KD subdiagonal, with
!>          the array TAU, represent the unitary matrix Q1 as a product
!>          of elementary reflectors. See Further Details.
!>

so on entry it's your Hermitian matrix, and on exit she's been overwritten — the triangle you gave her gets replaced by AB and the reflector tea. see Further Details for the receipts 👀

LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,N). 🎀
D — D is REAL array, dimension (N). The diagonal elements of the tridiagonal matrix T. ✨
E — E is REAL array, dimension (N-1). The off-diagonal elements of the tridiagonal matrix T. (yes N-1, she's shorter, it's fine 💅)
TAU — TAU is COMPLEX array, dimension (N-KD). The scalar factors of the elementary reflectors of the first stage (see Further Details).
HOUS2 — HOUS2 is COMPLEX array, dimension (MAX(1,LHOUS2)). Stores the Householder representation of the stage2 band to tridiagonal. 🦋
LHOUS2 — LHOUS2 is INTEGER. The dimension of the array HOUS2. LHOUS2 >= 1.

!>          If LWORK = -1, or LHOUS2=-1,
!>          then a query is assumed; the routine
!>          only calculates the optimal size of the HOUS2 array, returns
!>          this value as the first entry of the HOUS2 array, and no error
!>          message related to LHOUS2 is issued by XERBLA.
!>          If VECT='N', LHOUS2 = max(1, 4*n);
!>          if VECT='V', option not yet available.
!>

😭 reminder: VECT='V' → option not yet available. she said not today.

WORK — WORK is COMPLEX array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK. ⭐
LWORK — LWORK is INTEGER. The dimension of the array WORK. If N = 0, LWORK >= 1, else LWORK = MAX(1, dimension).

!>          If LWORK = -1, or LHOUS2 = -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.
!>          LWORK = MAX(1, dimension) where
!>          dimension   = max(stage1,stage2) + (KD+1)*N
!>                      = N*KD + N*max(KD+1,FACTOPTNB)
!>                        + max(2*KD*KD, KD*NTHREADS)
!>                        + (KD+1)*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.
!>

so KD = blocking size of the reduction, FACTOPTNB = the blocking used by the QR or LQ algorithm (usually FACTOPTNB=128 is a good choice, iykyk), and NTHREADS = number of threads used when openMP compilation is enabled, otherwise =1. 🌈

INFO — INFO is INTEGER:

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

💜 Author

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

🔥 Further Details

!>
!>  Implemented by Azzam Haidar.
!>
!>  All details are available on technical report, SC11, SC13 papers.
!>
!>  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
!>
!>

she's literally cited, she's that girl 🧚💖

👑 Definition

Definition at line 227 of file chetrd_2stage.f.

🌟 Author (again, but the meta one) 🌟

Generated automatically by Doxygen for LAPACK from the source code.

and that's the whole page, bestie 🫶 LAPACK, Version 3.12.0 — this lil SRC/chetrd_2stage.f(3) moment was brought to you by the source code and a very cute date, mwah 💋✨

📦 where this page comes from

arch rolling: lapack-doc 3.12.1-2 · custom
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms