Routine PZHEGS2() Documented By Universal Report

Routine: PZHEGS2()

# lines:	431
# code:	431
# comment:	0
# blank:	0
# Variables:	51
# Callers:	1
# Callings:	0
# Words:	237
# Keywords:	141

..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PZHEGS2 reduces a complex Hermitian-definite generalized eigenproblem
  to standard form.
  In the following sub( A ) denotes A( IA:IA+N-1, JA:JA+N-1 ) and
  sub( B ) denotes B( IB:IB+N-1, JB:JB+N-1 ).
  If IBTYPE = 1, the problem is sub( A )*x = lambda*sub( B )*x,
  and sub( A ) is overwritten by inv(U**H)*sub( A )*inv(U) or
  inv(L)*sub( A )*inv(L**H)
  If IBTYPE = 2 or 3, the problem is sub( A )*sub( B )*x = lambda*x or
  sub( B )*sub( A )*x = lambda*x, and sub( A ) is overwritten by
  U*sub( A )*U**H or L**H*sub( A )*L.
  sub( B ) must have been previously factorized as U**H*U or L*L**H by
  PZPOTRF.
  Notes
  =====
  Each global data object is described by an associated description
  vector.  This vector stores the information required to establish
  the mapping 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 column.
  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
  =========
  IBTYPE   (global input) INTEGER
          = 1: compute inv(U**H)*sub( A )*inv(U) or
               inv(L)*sub( A )*inv(L**H);
          = 2 or 3: compute U*sub( A )*U**H or L**H*sub( A )*L.
  UPLO    (global input) CHARACTER
          = 'U':  Upper triangle of sub( A ) is stored and sub( B ) is
                  factored as U**H*U;
          = 'L':  Lower triangle of sub( A ) is stored and sub( B ) is
                  factored as L*L**H.
  N       (global input) INTEGER
          The order of the matrices sub( A ) and sub( B ).  N >= 0.
  A       (local input/local output) COMPLEX*16 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
          N-by-N 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 triangular part of sub( A ) contains
          the lower triangular part of the matrix, and its strictly
          upper triangular part is not referenced.
          On exit, if INFO = 0, the transformed matrix, stored in the
          same format as sub( A ).
  IA      (global input) INTEGER
          A's global row index, which points to the beginning of the
          submatrix which is to be operated on.
  JA      (global input) INTEGER
          A's global column index, which points to the beginning of
          the submatrix which is to be operated on.
  DESCA   (global and local input) INTEGER array of dimension DLEN_.
          The array descriptor for the distributed matrix A.
  B       (local input) COMPLEX*16 pointer into the local memory
          to an array of dimension (LLD_B, LOCc(JB+N-1)). On entry,
          this array contains the local pieces of the triangular factor
          from the Cholesky factorization of sub( B ), as returned by
          PZPOTRF.
  IB      (global input) INTEGER
          B's global row index, which points to the beginning of the
          submatrix which is to be operated on.
  JB      (global input) INTEGER
          B's global column index, which points to the beginning of
          the submatrix which is to be operated on.
  DESCB   (global and local input) INTEGER array of dimension DLEN_.
          The array descriptor for the distributed matrix B.
  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.
  =====================================================================
     .. Parameters ..

Display dynamic version

FontSize: - +

001        SUBROUTINE PZHEGS2( IBTYPE , UPLO , N , A , IA , JA , DESCA , B , IB , JB ,
002       $DESCB , INFO )
003  
004  *     -- ScaLAPACK routine(version 1.7) --
005  *     University of Tennessee , Knoxville , Oak Ridge National Laboratory ,
006  *     and University of California , Berkeley.
007  *     May 1 , 1997
008  
009  *     .. Scalar Arguments ..
010        CHARACTER UPLO
011        INTEGER IA , IB , IBTYPE , INFO , JA , JB , N
012        INTEGER BLOCK_CYCLIC_2D , DLEN_ , DTYPE_ , CTXT_ , M_ , N_ ,
013       $MB_ , NB_ , RSRC_ , CSRC_ , LLD_
014        PARAMETER( BLOCK_CYCLIC_2D = 1 , DLEN_ = 9 , DTYPE_ = 1 ,
015       $CTXT_ = 2 , M_ = 3 , N_ = 4 , MB_ = 5 , NB_ = 6 ,
016       $RSRC_ = 7 , CSRC_ = 8 , LLD_ = 9 )
017        DOUBLE PRECISION ONE , HALF
018        PARAMETER( ONE = 1.0D + 0 , HALF = 0.5D + 0 )
019        COMPLEX*16 CONE
020        PARAMETER( CONE =( 1.0D + 0 , 0.0D + 0 ) )
021  *     ..
022  *     .. Local Scalars ..
023        LOGICAL UPPER
024        INTEGER IACOL , IAROW , IBCOL , IBROW , ICOFFA , ICOFFB ,
025       $ICTXT , IIA , IIB , IOFFA , IOFFB , IROFFA , IROFFB ,
026       $JJA , JJB , K , LDA , LDB , MYCOL , MYROW , NPCOL ,
027       $NPROW
028        DOUBLE PRECISION AKK , BKK
029        COMPLEX*16 CT
030  *     ..
031  *     .. External Subroutines ..
032        EXTERNAL BLACS_EXIT , BLACS_GRIDINFO , CHK1MAT , INFOG2L ,
033       $PXERBLA , ZAXPY , ZDSCAL , ZHER2 , ZLACGV , ZTRMV ,
034       $ZTRSV
035  *     ..
036  *     .. Intrinsic Functions ..
037        INTRINSIC DBLE , MOD
038  *     ..
039  *     .. External Functions ..
040        LOGICAL LSAME
041        INTEGER INDXG2P
042        EXTERNAL LSAME , INDXG2P
043  *     ..
044  *     .. Executable Statements ..
045  *     This is just to keep ftnchek happy
046        IF( BLOCK_CYCLIC_2D*CSRC_*CTXT_*DLEN_*DTYPE_*LLD_*MB_*M_*NB_*N_*
046               
047       $    RSRC_.LT.0 )RETURN
048  
049  *         Get grid parameters
050  
051            ICTXT = DESCA( CTXT_ )
052            CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
053  
054  *         Test the input parameters.
055  
056            INFO = 0
057            IF( NPROW.EQ. - 1 ) THEN
057                   
058                INFO = - ( 700 + CTXT_ )
059            ELSE
059                   
060                UPPER = LSAME( UPLO , 'U' )
061                CALL CHK1MAT( N , 3 , N , 3 , IA , JA , DESCA , 7 , INFO )
062                CALL CHK1MAT( N , 3 , N , 3 , IB , JB , DESCB , 11 , INFO )
063                IF( INFO.EQ.0 ) THEN
063                       
064                    IAROW = INDXG2P( IA , DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) ,
065       $            NPROW )
066                    IBROW = INDXG2P( IB , DESCB( MB_ ) , MYROW , DESCB( RSRC_ ) ,
067       $            NPROW )
068                    IACOL = INDXG2P( JA , DESCA( NB_ ) , MYCOL , DESCA( CSRC_ ) ,
069       $            NPCOL )
070                    IBCOL = INDXG2P( JB , DESCB( NB_ ) , MYCOL , DESCB( CSRC_ ) ,
071       $            NPCOL )
072                    IROFFA = MOD( IA - 1 , DESCA( MB_ ) )
073                    ICOFFA = MOD( JA - 1 , DESCA( NB_ ) )
074                    IROFFB = MOD( IB - 1 , DESCB( MB_ ) )
075                    ICOFFB = MOD( JB - 1 , DESCB( NB_ ) )
076                    IF( IBTYPE.LT.1 .OR. IBTYPE.GT.3 ) THEN
076                           
077                        INFO = - 1
078                    ELSE IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO , 'L' ) ) THEN
078                           
079                        INFO = - 2
080                    ELSE IF( N.LT.0 ) THEN
080                           
081                        INFO = - 3
082                    ELSE IF( N + ICOFFA.GT.DESCA( NB_ ) ) THEN
082                           
083                        INFO = - 3
084                    ELSE IF( IROFFA.NE.0 ) THEN
084                           
085                        INFO = - 5
086                    ELSE IF( ICOFFA.NE.0 ) THEN
086                           
087                        INFO = - 6
088                    ELSE IF( DESCA( MB_ ).NE.DESCA( NB_ ) ) THEN
088                           
089                        INFO = - ( 700 + NB_ )
090                    ELSE IF( IROFFB.NE.0 .OR. IBROW.NE.IAROW ) THEN
090                           
091                        INFO = - 9
092                    ELSE IF( ICOFFB.NE.0 .OR. IBCOL.NE.IACOL ) THEN
092                           
093                        INFO = - 10
094                    ELSE IF( DESCB( MB_ ).NE.DESCA( MB_ ) ) THEN
094                           
095                        INFO = - ( 1100 + MB_ )
096                    ELSE IF( DESCB( NB_ ).NE.DESCA( NB_ ) ) THEN
096                           
097                        INFO = - ( 1100 + NB_ )
098                    ELSE IF( ICTXT.NE.DESCB( CTXT_ ) ) THEN
098                           
099                        INFO = - ( 1100 + CTXT_ )
100                    END IF
101                END IF
102            END IF
103  
104            IF( INFO.NE.0 ) THEN
104                   
105                CALL PXERBLA( ICTXT , 'PZHEGS2' , - INFO )
106                CALL BLACS_EXIT( ICTXT )
107                RETURN
108            END IF
109  
110  *         Quick return if possible
111  
112            IF( N.EQ.0 .OR.( MYROW.NE.IAROW .OR. MYCOL.NE.IACOL ) )
112                   
113       $        RETURN
114  
115  *             Compute local information
116  
117                LDA = DESCA( LLD_ )
118                LDB = DESCB( LLD_ )
119                CALL INFOG2L( IA , JA , DESCA , NPROW , NPCOL , MYROW , MYCOL , IIA , JJA ,
120       $        IAROW , IACOL )
121                CALL INFOG2L( IA , JA , DESCA , NPROW , NPCOL , MYROW , MYCOL , IIB , JJB ,
122       $        IBROW , IBCOL )
123  
124                IF( IBTYPE.EQ.1 ) THEN
125  
125                       
126                    IF( UPPER ) THEN
127  
127                           
128                        IOFFA = IIA + JJA*LDA
129                        IOFFB = IIB + JJB*LDB
130  
131  *                     Compute inv(U')*sub( A )*inv(U)
132  
133                        DO 10 K = 1 , N
134  
135  *                         Update the upper triangle of
136  *                         A(ia + k - 1 : ia + n - a , ia + k - 1 : ia + n - 1)
137  
137                               
138                            AKK = DBLE( A( IOFFA - LDA ) )
139                            BKK = DBLE( B( IOFFB - LDB ) )
140                            AKK = AKK / BKK**2
141                            A( IOFFA - LDA ) = AKK
142                            IF( K.LT.N ) THEN
142                                   
143                                CALL ZDSCAL( N - K , ONE / BKK , A( IOFFA ) , LDA )
144                                CT = - HALF*AKK
145                                CALL ZLACGV( N - K , A( IOFFA ) , LDA )
146                                CALL ZLACGV( N - K , B( IOFFB ) , LDB )
147                                CALL ZAXPY( N - K , CT , B( IOFFB ) , LDB , A( IOFFA ) ,
148       $                        LDA )
149                                CALL ZHER2( UPLO , N - K , - CONE , A( IOFFA ) , LDA ,
150       $                        B( IOFFB ) , LDB , A( IOFFA + 1 ) , LDA )
151                                CALL ZAXPY( N - K , CT , B( IOFFB ) , LDB , A( IOFFA ) ,
152       $                        LDA )
153                                CALL ZLACGV( N - K , B( IOFFB ) , LDB )
154                                CALL ZTRSV( UPLO , 'Conjugate transpose' , 'Non - unit' ,
155       $                        N - K , B( IOFFB + 1 ) , LDB , A( IOFFA ) , LDA )
156                                CALL ZLACGV( N - K , A( IOFFA ) , LDA )
157                            END IF
158  
159  *                         A( IOFFA ) -> A( K , K + 1 )
160  *                         B( IOFFB ) -> B( K , K + 1 )
161  
162                            IOFFA = IOFFA + LDA + 1
163                            IOFFB = IOFFB + LDB + 1
164  
165     10                 CONTINUE
166  
166                       
167                    ELSE
168  
168                           
169                        IOFFA = IIA + 1 + ( JJA - 1 )*LDA
170                        IOFFB = IIB + 1 + ( JJB - 1 )*LDB
171  
172  *                     Compute inv(L)*sub( A )*inv(L')
173  
174                        DO 20 K = 1 , N
175  
176  *                         Update the lower triangle of
177  *                         A(ia + k - 1 : ia + n - a , ia + k - 1 : ia + n - 1)
178  
178                               
179                            AKK = DBLE( A( IOFFA - 1 ) )
180                            BKK = DBLE( B( IOFFB - 1 ) )
181                            AKK = AKK / BKK**2
182                            A( IOFFA - 1 ) = AKK
183  
184                            IF( K.LT.N ) THEN
184                                   
185                                CALL ZDSCAL( N - K , ONE / BKK , A( IOFFA ) , 1 )
186                                CT = - HALF*AKK
187                                CALL ZAXPY( N - K , CT , B( IOFFB ) , 1 , A( IOFFA ) , 1 )
188                                CALL ZHER2( UPLO , N - K , - CONE , A( IOFFA ) , 1 ,
189       $                        B( IOFFB ) , 1 , A( IOFFA + LDA ) , LDA )
190                                CALL ZAXPY( N - K , CT , B( IOFFB ) , 1 , A( IOFFA ) , 1 )
191                                CALL ZTRSV( UPLO , 'No transpose' , 'Non - unit' , N - K ,
192       $                        B( IOFFB + LDB ) , LDB , A( IOFFA ) , 1 )
193                            END IF
194  
195  *                         A( IOFFA ) -> A( K + 1 , K )
196  *                         B( IOFFB ) -> B( K + 1 , K )
197  
198                            IOFFA = IOFFA + LDA + 1
199                            IOFFB = IOFFB + LDB + 1
200  
201     20                 CONTINUE
202  
202                       
203                    END IF
204  
205                ELSE
206  
206                       
207                    IF( UPPER ) THEN
208  
208                           
209                        IOFFA = IIA + ( JJA - 1 )*LDA
210                        IOFFB = IIB + ( JJB - 1 )*LDB
211  
212  *                     Compute U*sub( A )*U'
213  
214                        DO 30 K = 1 , N
215  
216  *                         Update the upper triangle of A(ia : ia + k - 1 , ja : ja + k - 1)
217  
217                               
218                            AKK = DBLE( A( IOFFA + K - 1 ) )
219                            BKK = DBLE( B( IOFFB + K - 1 ) )
220                            CALL ZTRMV( UPLO , 'No transpose' , 'Non - unit' , K - 1 ,
221       $                    B( IIB + ( JJB - 1 )*LDB ) , LDB , A( IOFFA ) , 1 )
222                            CT = HALF*AKK
223                            CALL ZAXPY( K - 1 , CT , B( IOFFB ) , 1 , A( IOFFA ) , 1 )
224                            CALL ZHER2( UPLO , K - 1 , CONE , A( IOFFA ) , 1 , B( IOFFB ) ,
225       $                    1 , A( IIA + ( JJA - 1 )*LDA ) , LDA )
226                            CALL ZAXPY( K - 1 , CT , B( IOFFB ) , 1 , A( IOFFA ) , 1 )
227                            CALL ZDSCAL( K - 1 , BKK , A( IOFFA ) , 1 )
228                            A( IOFFA + K - 1 ) = AKK*BKK**2
229  
230  *                         A( IOFFA ) -> A( 1 , K )
231  *                         B( IOFFB ) -> B( 1 , K )
232  
233                            IOFFA = IOFFA + LDA
234                            IOFFB = IOFFB + LDB
235  
236     30                 CONTINUE
237  
237                       
238                    ELSE
239  
239                           
240                        IOFFA = IIA + ( JJA - 1 )*LDA
241                        IOFFB = IIB + ( JJB - 1 )*LDB
242  
243  *                     Compute L'*sub( A )*L
244  
245                        DO 40 K = 1 , N
246  
247  *                         Update the lower triangle of A(ia : ia + k - 1 , ja : ja + k - 1)
248  
248                               
249                            AKK = DBLE( A( IOFFA + ( K - 1 )*LDA ) )
250                            BKK = DBLE( B( IOFFB + ( K - 1 )*LDB ) )
251                            CALL ZLACGV( K - 1 , A( IOFFA ) , LDA )
252                            CALL ZTRMV( UPLO , 'Conjugate transpose' , 'Non - unit' , K - 1 ,
253       $                    B( IIB + ( JJB - 1 )*LDB ) , LDB , A( IOFFA ) ,
254       $                    LDA )
255                            CT = HALF*AKK
256                            CALL ZLACGV( K - 1 , B( IOFFB ) , LDB )
257                            CALL ZAXPY( K - 1 , CT , B( IOFFB ) , LDB , A( IOFFA ) , LDA )
258                            CALL ZHER2( UPLO , K - 1 , CONE , A( IOFFA ) , LDA , B( IOFFB ) ,
259       $                    LDB , A( IIA + ( JJA - 1 )*LDA ) , LDA )
260                            CALL ZAXPY( K - 1 , CT , B( IOFFB ) , LDB , A( IOFFA ) , LDA )
261                            CALL ZLACGV( K - 1 , B( IOFFB ) , LDB )
262                            CALL ZDSCAL( K - 1 , BKK , A( IOFFA ) , LDA )
263                            CALL ZLACGV( K - 1 , A( IOFFA ) , LDA )
264                            A( IOFFA + ( K - 1 )*LDA ) = AKK*BKK**2
265  
266  *                         A( IOFFA ) -> A( K , 1 )
267  *                         B( IOFFB ) -> B( K , 1 )
268  
269                            IOFFA = IOFFA + 1
270                            IOFFB = IOFFB + 1
271  
272     40                 CONTINUE
273  
273                       
274                    END IF
275  
276                END IF
277  
278                RETURN
279  
280  *             End of PZHEGS2
281  
282            END3956

Variables in Routine PZHEGS2()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	1	1
*COMPLEX16**	2	?
DOUBLE PRECISION	4	16
INTEGER	41	164
LOGICAL	2	2
REAL	1	4
TOTAL	51	187

List of Variables

CHARACTER

UPLO

COMPLEX*16

CONE CT

DOUBLE PRECISION

AKK BKK HALF ONE

INTEGER

BLOCK_CYCLIC_2D CSRC_ CTXT_ DLEN_ DTYPE_
IA IACOL IAROW IB IBCOL
IBROW IBTYPE ICOFFA ICOFFB ICTXT
IIA IIB INDXG2P INFO IOFFA
IOFFB IROFFA IROFFB JA JB
JJA JJB K LDA LDB
LLD_ M_ MB_ MYCOL MYROW
N N_ NB_ NPCOL NPROW
RSRC_

LOGICAL

LSAME UPPER

REAL

A

Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence
-
- -
A <--- AKKA( IOFFA-LDA ) = AKK{2A( IOFFA-1 ) = AKK, 3A( IOFFA+K-1 ) = AKK*BKK**2, 4A( IOFFA+( K-1 )*LDA ) = AKK*BKK**2}, BKKA( IOFFA+K-1 ) = AKK*BKK**2{2A( IOFFA+( K-1 )*LDA ) = AKK*BKK**2}

AKK <--- AAKK = DBLE( A( IOFFA-LDA ) ){2AKK = DBLE( A( IOFFA-1 ) ), 3AKK = DBLE( A( IOFFA+K-1 ) ), 4AKK = DBLE( A( IOFFA+( K-1 )*LDA ) )}, AKKAKK = AKK / BKK**2{2AKK = AKK / BKK**2}, IOFFAAKK = DBLE( A( IOFFA-LDA ) ){2AKK = DBLE( A( IOFFA-1 ) ), 3AKK = DBLE( A( IOFFA+K-1 ) ), 4AKK = DBLE( A( IOFFA+( K-1 )*LDA ) )}, BKKAKK = AKK / BKK**2{2AKK = AKK / BKK**2}, KAKK = DBLE( A( IOFFA+K-1 ) ){2AKK = DBLE( A( IOFFA+( K-1 )*LDA ) )}, LDAAKK = DBLE( A( IOFFA-LDA ) ){2AKK = DBLE( A( IOFFA+( K-1 )*LDA ) )}

BKK <--- IOFFBBKK = DBLE( B( IOFFB-LDB ) ){2BKK = DBLE( B( IOFFB-1 ) ), 3BKK = DBLE( B( IOFFB+K-1 ) ), 4BKK = DBLE( B( IOFFB+( K-1 )*LDB ) )}, KBKK = DBLE( B( IOFFB+K-1 ) ){2BKK = DBLE( B( IOFFB+( K-1 )*LDB ) )}, LDBBKK = DBLE( B( IOFFB-LDB ) ){2BKK = DBLE( B( IOFFB+( K-1 )*LDB ) )}

CT <--- HALFCT = -HALF*AKK{2CT = -HALF*AKK, 3CT = HALF*AKK, 4CT = HALF*AKK}, AKKCT = -HALF*AKK{2CT = -HALF*AKK, 3CT = HALF*AKK, 4CT = HALF*AKK}

IACOL <--- INDXG2P, JA, MYCOL, NB_, NPCOL, CSRC_

IAROW <--- IA, INDXG2P, MB_, MYROW, NPROW, RSRC_

IBCOL <--- INDXG2P, JB, MYCOL, NB_, NPCOL, CSRC_

IBROW <--- IB, INDXG2P, MB_, MYROW, NPROW, RSRC_

ICOFFA <--- JAICOFFA = MOD( JA-1, DESCA( NB_ ) ), NB_ICOFFA = MOD( JA-1, DESCA( NB_ ) )

ICOFFB <--- JBICOFFB = MOD( JB-1, DESCB( NB_ ) ), NB_ICOFFB = MOD( JB-1, DESCB( NB_ ) )

ICTXT <--- CTXT_ICTXT = DESCA( CTXT_ )

INFO <--- MB_INFO = -( 1100+MB_ ), NB_INFO = -( 700+NB_ ){2INFO = -( 1100+NB_ )}, CTXT_INFO = -( 700+CTXT_ ){2INFO = -( 1100+CTXT_ )}

IOFFA <--- IIAIOFFA = IIA + JJA*LDA{2IOFFA = IIA + 1 + ( JJA-1 )*LDA, 3IOFFA = IIA + ( JJA-1 )*LDA, 4IOFFA = IIA + ( JJA-1 )*LDA}, IOFFAIOFFA = IOFFA + LDA + 1{2IOFFA = IOFFA + LDA + 1, 3IOFFA = IOFFA + LDA, 4IOFFA = IOFFA + 1}, JJAIOFFA = IIA + JJA*LDA{2IOFFA = IIA + 1 + ( JJA-1 )*LDA, 3IOFFA = IIA + ( JJA-1 )*LDA, 4IOFFA = IIA + ( JJA-1 )*LDA}, LDAIOFFA = IIA + JJA*LDA{2IOFFA = IOFFA + LDA + 1, 3IOFFA = IIA + 1 + ( JJA-1 )*LDA, 4IOFFA = IOFFA + LDA + 1, 5IOFFA = IIA + ( JJA-1 )*LDA, 6IOFFA = IOFFA + LDA, 7IOFFA = IIA + ( JJA-1 )*LDA}

IOFFB <--- IIBIOFFB = IIB + JJB*LDB{2IOFFB = IIB + 1 + ( JJB-1 )*LDB, 3IOFFB = IIB + ( JJB-1 )*LDB, 4IOFFB = IIB + ( JJB-1 )*LDB}, IOFFBIOFFB = IOFFB + LDB + 1{2IOFFB = IOFFB + LDB + 1, 3IOFFB = IOFFB + LDB, 4IOFFB = IOFFB + 1}, JJBIOFFB = IIB + JJB*LDB{2IOFFB = IIB + 1 + ( JJB-1 )*LDB, 3IOFFB = IIB + ( JJB-1 )*LDB, 4IOFFB = IIB + ( JJB-1 )*LDB}, LDBIOFFB = IIB + JJB*LDB{2IOFFB = IOFFB + LDB + 1, 3IOFFB = IIB + 1 + ( JJB-1 )*LDB, 4IOFFB = IOFFB + LDB + 1, 5IOFFB = IIB + ( JJB-1 )*LDB, 6IOFFB = IOFFB + LDB, 7IOFFB = IIB + ( JJB-1 )*LDB}

IROFFA <--- IAIROFFA = MOD( IA-1, DESCA( MB_ ) ), MB_IROFFA = MOD( IA-1, DESCA( MB_ ) )

IROFFB <--- IBIROFFB = MOD( IB-1, DESCB( MB_ ) ), MB_IROFFB = MOD( IB-1, DESCB( MB_ ) )

K <--- NDO 10 K = 1, N{2DO 20 K = 1, N, 3DO 30 K = 1, N, 4DO 40 K = 1, N}

LDA <--- LLD_LDA = DESCA( LLD_ )

LDB <--- LLD_LDB = DESCB( LLD_ )

UPPER <--- LSAMEUPPER = LSAME( UPLO, 'U' ), UPLOUPPER = LSAME( UPLO, 'U' )

Analysis elements of the routine PZHEGS2()
Put the mouse over each element to display detailed matching information

Assigned variables
		AKK , BKK , BLOCK_CYCLIC_2D , CONE , CSRC_ , CT , CTXT_ , DLEN_ , DTYPE_ , HALF , IACOL , IAROW , IBCOL , IBROW , ICOFFA , ICOFFB , ICTXT , INFO , IOFFA , IOFFB , IROFFA , IROFFB , K , LDA , LDB , LLD_ , M_ , MB_ , N_ , NB_ , ONE , RSRC_ , UPPER

Active variables
		A , AKK , B , BKK , BLOCK_CYCLIC_2D , CONE , CSRC_ , CT , CTXT_ , DESCA , DESCB , DLEN_ , DTYPE_ , HALF , IA , IACOL , IAROW , IB , IBCOL , IBROW , IBTYPE , ICOFFA , ICOFFB , ICTXT , IIA , IIB , INDXG2P , INFO , IOFFA , IOFFB , IROFFA , IROFFB , JA , JB , JJA , JJB , K , LDA , LDB , LLD_ , LSAME , M_ , MB_ , MYCOL , MYROW , N , N_ , NB_ , NPCOL , NPROW , ONE , RSRC_ , UPLO , UPPER

Accessed arrays [ array name : associated index ]
	A	: 1, K , ia:ia+k-1,ja:ja+k-1 , ia:ia+k-1,ja:ja+k-1 , ia+k-1:ia+n-a,ia+k-1:ia+n-1 , ia+k-1:ia+n-a,ia+k-1:ia+n-1 , IIA+( JJA-1 )LDA , IIA+( JJA-1 )LDA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA , IOFFA+( K-1 )LDA , IOFFA+( K-1 )LDA , IOFFA+1 , IOFFA+K-1 , IOFFA+K-1 , IOFFA+LDA , IOFFA-1 , IOFFA-1 , IOFFA-LDA , IOFFA-LDA , K, 1 , K, K+1 , K+1, K
	B	: 1, K , IIB+( JJB-1 )LDB , IIB+( JJB-1 )LDB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB , IOFFB+( K-1 )*LDB , IOFFB+1 , IOFFB+K-1 , IOFFB+LDB , IOFFB-1 , IOFFB-LDB , K, 1 , K, K+1 , K+1, K
	DESCA	: CSRC_ , CTXT_ , LLD_ , MB_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_ , NB_ , RSRC_
	DESCB	: CSRC_ , CTXT_ , LLD_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , RSRC_
	LSAME	: UPLO, 'L' , UPLO, 'U'

Conditional statements [ statement : associated predicate ]
	do	: `(` 10 K = 1 , N `)` , `(` 20 K = 1 , N `)` , `(` 30 K = 1 , N `)` , `(` 40 K = 1 , N `)`
	if	: `(` BLOCK_CYCLIC_2DCSRC_CTXT_DLEN_DTYPE_LLD_MB_M_NB_N_ `)` , `(` NPROW.EQ. - 1 `)` , `(` INFO.EQ.0 `)` , `(` IBTYPE.LT.1 .OR. IBTYPE.GT.3 `)` , `(` (.NOT.UPPER .AND. .NOT.LSAME( UPLO , 'L' ) ) `)` , `(` N.LT.0 `)` , `(` (N+ICOFFA.GT.DESCA( NB_ ) ) `)` , `(` IROFFA.NE.0 `)` , `(` ICOFFA.NE.0 `)` , `(` (DESCA( MB_ ).NE.DESCA( NB_ ) ) `)` , `(` IROFFB.NE.0 .OR. IBROW.NE.IAROW `)` , `(` ICOFFB.NE.0 .OR. IBCOL.NE.IACOL `)` , `(` (DESCB( MB_ ).NE.DESCA( MB_ ) ) `)` , `(` (DESCB( NB_ ).NE.DESCA( NB_ ) ) `)` , `(` (ICTXT.NE.DESCB( CTXT_ ) ) `)` , `(` INFO.NE.0 `)` , `(` possible `)` , `(` (N.EQ.0 .OR. ( MYROW.NE.IAROW .OR. MYCOL.NE.IACOL ) ) `)` , `(` IBTYPE.EQ.1 `)` , `(` UPPER `)` , `(` K.LT.N `)` , `(` K.LT.N `)` , `(` UPPER `)`