PCHETTRD(3)   ScaLAPACK routine of NEC Numeric Library Collection  PCHETTRD(3)



NAME
       PCHENTRD  -  reduce  a  complex  Hermitian matrix sub( A ) to Hermitian
       tridiagonal form T by an unitary similarity transformation

SYNOPSIS
       SUBROUTINE PCHETTRD(
                           UPLO, N, A, IA, JA, DESCA, D, E, TAU, WORK,  LWORK,
                           INFO )

           CHARACTER       UPLO

           INTEGER         IA, INFO, JA, LWORK, N

           INTEGER         DESCA( * )

           REAL            D( * ), E( * )

           COMPLEX*8       A( * ), TAU( * ), WORK( * )

PURPOSE
       PCHETTRD  reduces  a  complex  Hermitian  matrix  sub( A ) to Hermitian
       tridiagonal form T by an orthogonal  similarity  transformation:  Q'  *
       sub( A ) * Q = T, where sub( A ) = A(IA:IA+N-1,JA:JA+N-1).

       Notes
       =====

       Each  global data object is described by an associated description vec-
       tor.  This vector stores the information required to establish the map-
       ping between an object element and its corresponding process and memory
       location.

       Let A be a generic term for any 2D block  cyclicly  distributed  array.
       Such a global array has an associated description vector DESCA.  In the
       following comments, the character _ should be read as  "of  the  global
       array".

       NOTATION        STORED IN      EXPLANATION
       --------------- -------------- --------------------------------------
       DTYPE_A(global) DESCA( DTYPE_ )The descriptor type.  In this case,
                                      DTYPE_A = 1.
       CTXT_A (global) DESCA( CTXT_ ) The BLACS context handle, indicating
                                      the BLACS process grid A is distribu-
                                      ted over. The context itself is glo-
                                      bal, but the handle (the integer
                                      value) may vary.
       M_A    (global) DESCA( M_ )    The number of rows in the global
                                      array A.
       N_A    (global) DESCA( N_ )    The number of columns in the global
                                      array A.
       MB_A   (global) DESCA( MB_ )   The blocking factor used to distribute
                                      the rows of the array.
       NB_A   (global) DESCA( NB_ )   The blocking factor used to distribute
                                      the columns of the array.
       RSRC_A (global) DESCA( RSRC_ ) The process row over which the first
                                      row  of  the  array  A  is  distributed.
       CSRC_A (global) DESCA( CSRC_ ) The process column over which the
                                      first column of the array A is
                                      distributed.
       LLD_A  (local)  DESCA( LLD_ )  The leading dimension of the local
                                      array.  LLD_A >= MAX(1,LOCr(M_A)).

       Let K be the number of rows or columns of  a  distributed  matrix,  and
       assume that its process grid has dimension p x q.
       LOCr(  K  )  denotes  the  number of elements of K that a process would
       receive if K were distributed over the p processes of its process  col-
       umn.
       Similarly, LOCc( K ) denotes the number of elements of K that a process
       would receive if K were distributed over the q processes of its process
       row.
       The  values  of  LOCr()  and LOCc() may be determined via a call to the
       ScaLAPACK tool function, NUMROC:
               LOCr( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
               LOCc( N ) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).  An  upper
       bound for these quantities may be computed by:
               LOCr( M ) <= ceil( ceil(M/MB_A)/NPROW )*MB_A
               LOCc( N ) <= ceil( ceil(N/NB_A)/NPCOL )*NB_A


ARGUMENTS
       UPLO    (global input) CHARACTER
               Specifies  whether  the  upper  or lower triangular part of the
               symmetric matrix sub( A ) is stored:
               = 'U':  Upper triangular
               = 'L':  Lower triangular

       N       (global input) INTEGER
               The number of rows and columns to  be  operated  on,  i.e.  the
               order of the distributed submatrix sub( A ). N >= 0.

       A       (local input/local output) COMPLEX*8 pointer into the
               local memory to an array of dimension (LLD_A,LOCc(JA+N-1)).  On
               entry, this array contains the local pieces  of  the  Hermitian
               distributed matrix sub( A ).  If UPLO = 'U', the leading N-by-N
               upper triangular part of sub( A ) contains the upper triangular
               part  of  the matrix, and its strictly lower triangular part is
               not referenced. If UPLO = 'L', the leading N-by-N lower  trian-
               gular  part  of  sub( A ) contains the lower triangular part of
               the matrix, and its strictly upper triangular part is not  ref-
               erenced.  On exit, if UPLO = 'U', the diagonal and first super-
               diagonal of sub( A ) are over-  written  by  the  corresponding
               elements  of  the  tridiagonal matrix T, and the elements above
               the first superdiagonal, with  the  array  TAU,  represent  the
               orthogonal  matrix  Q as a product of elementary reflectors; if
               UPLO = 'L', the diagonal and first subdiagonal of sub( A )  are
               overwritten  by  the  corresponding elements of the tridiagonal
               matrix T, and the elements below the  first  subdiagonal,  with
               the  array  TAU, represent the orthogonal matrix Q as a product
               of elementary reflectors. See Further Details.

       IA      (global input) INTEGER
               The row index in the global array A indicating the first row of
               sub( A ).

       JA      (global input) INTEGER
               The  column  index  in  the global array A indicating the first
               column of sub( A ).

       DESCA   (global and local input) INTEGER array of dimension DLEN_.
               The array descriptor for the distributed matrix A.

       D       (local output) REAL array, dimension LOCc(JA+N-1)
               The diagonal elements of  the  tridiagonal  matrix  T:  D(i)  =
               A(i,i). D is tied to the distributed matrix A.

       E       (local output) REAL array, dimension LOCc(JA+N-1)
               if  UPLO  =  'U', LOCc(JA+N-2) otherwise. The off-diagonal ele-
               ments of the tridiagonal matrix T: E(i) = A(i,i+1)  if  UPLO  =
               'U',  E(i)  =  A(i+1,i)  if  UPLO  = 'L'. E is tied to the dis-
               tributed matrix A.

       TAU     (local output) COMPLEX*8 array, dimension
               LOCc(JA+N-1). This array contains the scalar factors TAU of the
               elementary reflectors. TAU is tied to the distributed matrix A.

       WORK     (local  workspace/local  output)  COMPLEX*8  array,  dimension
       (LWORK)
               On exit, WORK( 1 ) returns the minimal and optimal LWORK.

       LWORK   (local or global input) INTEGER
               The dimension of the  array  WORK.   LWORK  >=  2*(  ANB+1  )*(
               4*NPS+2 ) + NPS
               Where:
                   NPS = MAX( NUMROC( N, 1, 0, 0, NPROW ), 2*ANB )
                   ANB = PJLAENV( DESCA( CTXT_ ), 3, 'PCHETTRD', 'L', 0, 0,
                     0, 0 )

                   NUMROC is a ScaLAPACK tool function;
                   PJLAENV is a ScaLAPACK envionmental inquiry function
                   MYROW, MYCOL, NPROW and NPCOL can be determined by calling
                   the subroutine BLACS_GRIDINFO.

       INFO    (global output) INTEGER
               = 0:  successful exit
               <  0:   If the i-th argument is an array and the j-entry had an
               illegal value, then INFO = -(i*100+j), if the i-th argument  is
               a scalar and had an illegal value, then INFO = -i.

FURTHER DETAILS
       If  UPLO  = 'U', the matrix Q is represented as a product of elementary
       reflectors

          Q = H(n-1) . . . H(2) H(1).

       Each H(i) has the form

          H(i) = I - tau * v * v'

       where tau is a real scalar, and v is a real vector with
       v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in
       A(ia:ia+i-2,ja+i), and tau in TAU(ja+i-1).

       If UPLO = 'L', the matrix Q is represented as a product  of  elementary
       reflectors

          Q = H(1) H(2) . . . H(n-1).

       Each H(i) has the form

          H(i) = I - tau * v * v'

       where tau is a real scalar, and v is a real vector with
       v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in
       A(ia+i+1:ia+n-1,ja+i-1), and tau in TAU(ja+i-1).

       The contents of sub( A ) on exit are illustrated by the following exam-
       ples with n = 5:

       if UPLO = 'U':                       if UPLO = 'L':

         (  d   e   v2  v3  v4 )              (  d                  )
         (      d   e   v3  v4 )              (  e   d              )
         (          d   e   v4 )              (  v1  e   d          )
         (              d   e  )              (  v1  v2  e   d      )
         (                  d  )              (  v1  v2  v3  e   d  )

       where d and e denote diagonal and off-diagonal elements of  T,  and  vi
       denotes an element of the vector defining H(i).


ALIGNMENT REQUIREMENTS
       The  distributed  submatrix sub( A ) must verify some alignment proper-
       ties, namely the following expression should be true:
       ( MB_A.EQ.NB_A .AND. IROFFA.EQ.ICOFFA .AND. IROFFA.EQ.0 ) with IROFFA =
       MOD( IA-1, MB_A ) and ICOFFA = MOD( JA-1, NB_A ).




ScaLAPACK routine               31 October 2017                    PCHETTRD(3)