Loading...
Searching...
No Matches

## zhetrd_2stage()

subroutine zhetrd_2stage | ( | character | vect,
|  | character | uplo,
|  | integer | n,
|  | complex*16, dimension( lda, * ) | a,
|  | integer | lda,
|  | double precision, dimension( * ) | d,
|  | double precision, dimension( * ) | e,
|  | complex*16, dimension( * ) | tau,
|  | complex*16, dimension( * ) | hous2,
|  | integer | lhous2,
|  | complex*16, dimension( * ) | work,
|  | integer | lwork,
|  | integer | info )

ZHETRD_2STAGE

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

Purpose:

      !>
      !> ZHETRD_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.
      !>

Parameters

  [in]

  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).
      !>

  [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 COMPLEX*16 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.
      !>

  [in]

  LDA

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

  [out]

  D

      !>          D is DOUBLE PRECISION array, dimension (N)
      !>          The diagonal elements of the tridiagonal matrix T.
      !>

  [out]

  E

      !>          E is DOUBLE PRECISION array, dimension (N-1)
      !>          The off-diagonal elements of the tridiagonal matrix T.
      !>

  [out]

  TAU

      !>          TAU is COMPLEX*16 array, dimension (N-KD)
      !>          The scalar factors of the elementary reflectors of
      !>          the first stage (see Further Details).
      !>

  [out]

  HOUS2

      !>          HOUS2 is COMPLEX*16 array, dimension (MAX(1,LHOUS2))
      !>          Stores the Householder representation of the stage2
      !>          band to tridiagonal.
      !>

  [in]

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

  [out]

  WORK

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

  [in]

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

  [out]

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