Routine PCUNML2() Documented By Universal Report

Routine: PCUNML2()

File: SRC\pcunml2.f

# lines:	402
# code:	402
# comment:	0
# blank:	0
# Variables:	59
# Callers:	1
# Callings:	3
# Words:	215
# Keywords:	139

..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PCUNML2 overwrites the general complex M-by-N distributed matrix
  sub( C ) = C(IC:IC+M-1,JC:JC+N-1) with
                       SIDE = 'L'          SIDE = 'R'
  TRANS = 'N':      Q * sub( C )         sub( C ) * Q
  TRANS = 'C':      Q**H * sub( C        sub( C ) * Q**H
  where Q is a complex unitary distributed matrix defined as the
  product of K elementary reflectors
        Q = H(k)' . . . H(2)' H(1)'
  as returned by PCGELQF. Q is of order M if SIDE = 'L' and of order N
  if SIDE = 'R'.
  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
  =========
  SIDE    (global input) CHARACTER
          = 'L': apply Q or Q**H from the Left;
          = 'R': apply Q or Q**H from the Right.
  TRANS   (global input) CHARACTER
          = 'N':  No transpose, apply Q;
          = 'C':  Conjugate transpose, apply Q**H.
  M       (global input) INTEGER
          The number of rows to be operated on i.e the number of rows
          of the distributed submatrix sub( C ). M >= 0.
  N       (global input) INTEGER
          The number of columns to be operated on i.e the number of
          columns of the distributed submatrix sub( C ). N >= 0.
  K       (global input) INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q.  If SIDE = 'L', M >= K >= 0, if SIDE = 'R',
          N >= K >= 0.
  A       (local input) COMPLEX pointer into the local memory
          to an array of dimension (LLD_A,LOCc(JA+M-1)) if SIDE='L',
          and (LLD_A,LOCc(JA+N-1)) if SIDE='R', where
          LLD_A >= max(1,LOCr(IA+K-1)); On entry, the i-th row must
          contain the vector which defines the elementary reflector
          H(i), IA <= i <= IA+K-1, as returned by PCGELQF in the
          K rows of its distributed matrix argument A(IA:IA+K-1,JA:*).
          A(IA:IA+K-1,JA:*) is modified by the routine but restored on
          exit.
  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.
  TAU     (local input) COMPLEX, array, dimension LOCc(IA+K-1).
          This array contains the scalar factors TAU(i) of the
          elementary reflectors H(i) as returned by PCGELQF.
          TAU is tied to the distributed matrix A.
  C       (local input/local output) COMPLEX pointer into the
          local memory to an array of dimension (LLD_C,LOCc(JC+N-1)).
          On entry, the local pieces of the distributed matrix sub(C).
          On exit, sub( C ) is overwritten by Q*sub( C ) or Q'*sub( C )
          or sub( C )*Q' or sub( C )*Q.
  IC      (global input) INTEGER
          The row index in the global array C indicating the first
          row of sub( C ).
  JC      (global input) INTEGER
          The column index in the global array C indicating the
          first column of sub( C ).
  DESCC   (global and local input) INTEGER array of dimension DLEN_.
          The array descriptor for the distributed matrix C.
  WORK    (local workspace/local output) COMPLEX 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 is local input and must be at least
          If SIDE = 'L', LWORK >= MpC0 + MAX( MAX( 1, NqC0 ), NUMROC(
                  NUMROC( M+IROFFC,MB_A,0,0,NPROW ),MB_A,0,0,LCMP ) );
          if SIDE = 'R', LWORK >= NqC0 + MAX( 1, MpC0 );
          where LCMP = LCM / NPROW with LCM = ICLM( NPROW, NPCOL ),
          IROFFC = MOD( IC-1, MB_C ), ICOFFC = MOD( JC-1, NB_C ),
          ICROW = INDXG2P( IC, MB_C, MYROW, RSRC_C, NPROW ),
          ICCOL = INDXG2P( JC, NB_C, MYCOL, CSRC_C, NPCOL ),
          MpC0 = NUMROC( M+IROFFC, MB_C, MYROW, ICROW, NPROW ),
          NqC0 = NUMROC( N+ICOFFC, NB_C, MYCOL, ICCOL, NPCOL ),
          ILCM, INDXG2P and NUMROC are ScaLAPACK tool functions;
          MYROW, MYCOL, NPROW and NPCOL can be determined by calling
          the subroutine BLACS_GRIDINFO.
          If LWORK = -1, then LWORK is global input and a workspace
          query is assumed; the routine only calculates the minimum
          and optimal size for all work arrays. Each of these
          values is returned in the first entry of the corresponding
          work array, and no error message is issued by PXERBLA.
  INFO    (local 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.
  Alignment requirements
  ======================
  The distributed submatrices A(IA:*, JA:*) and C(IC:IC+M-1,JC:JC+N-1)
  must verify some alignment properties, namely the following
  expressions should be true:
  If SIDE = 'L',
    ( NB_A.EQ.MB_C .AND. ICOFFA.EQ.IROFFC )
  If SIDE = 'R',
    ( NB_A.EQ.NB_C .AND. ICOFFA.EQ.ICOFFC .AND. IACOL.EQ.ICCOL )
  =====================================================================
     .. Parameters ..

Display dynamic version

FontSize: - +

001        SUBROUTINE PCUNML2( SIDE , TRANS , M , N , K , A , IA , JA , DESCA , TAU ,
002       $C , IC , JC , DESCC , WORK , LWORK , 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 25 , 2001
008  
009  *     .. Scalar Arguments ..
010        CHARACTER SIDE , TRANS
011        INTEGER IA , IC , INFO , JA , JC , K , LWORK , M , N
012        INTEGER BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ ,
013       $LLD_ , MB_ , M_ , NB_ , N_ , RSRC_
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        COMPLEX ONE
018        PARAMETER( ONE =( 1.0E + 0 , 0.0E + 0 ) )
019  *     ..
020  *     .. Local Scalars ..
021        LOGICAL LEFT , LQUERY , NOTRAN
022        CHARACTER COLBTOP , ROWBTOP
023        INTEGER I , I1 , I2 , I3 , IACOL , ICC , ICCOL , ICOFFA ,
024       $ICOFFC , ICROW , ICTXT , IROFFC , JCC , LCM , LCMP ,
025       $LWMIN , MI , MPC0 , MYCOL , MYROW , NI , NPCOL ,
026       $NPROW , NQ , NQC0
027        COMPLEX AII
028  *     ..
029  *     .. External Subroutines ..
030        EXTERNAL BLACS_ABORT , BLACS_GRIDINFO , CHK1MAT , PCELSET ,
031       $PCELSET2 , PCLACGV , PCLARF , PCLARFC ,
032       $PB_TOPGET , PB_TOPSET , PXERBLA
033  *     ..
034  *     .. External Functions ..
035        LOGICAL LSAME
036        INTEGER ILCM , INDXG2P , NUMROC
037        EXTERNAL ILCM , INDXG2P , LSAME , NUMROC
038  *     ..
039  *     .. Intrinsic Functions ..
040        INTRINSIC CMPLX , MAX , MOD , REAL
041  *     ..
042  *     .. Executable Statements ..
043  
044  *     Get grid parameters
045  
046        ICTXT = DESCA( CTXT_ )
047        CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
048  
049  *     Test the input parameters
050  
051        INFO = 0
052        IF( NPROW.EQ. - 1 ) THEN
052               
053            INFO = - (900 + CTXT_)
054        ELSE
054               
055            LEFT = LSAME( SIDE , 'L' )
056            NOTRAN = LSAME( TRANS , 'N' )
057  
058  *         NQ is the order of Q
059  
060            IF( LEFT ) THEN
060                   
061                NQ = M
062                CALL CHK1MAT( K , 5 , M , 3 , IA , JA , DESCA , 9 , INFO )
063            ELSE
063                   
064                NQ = N
065                CALL CHK1MAT( K , 5 , N , 4 , IA , JA , DESCA , 9 , INFO )
066            END IF
067            CALL CHK1MAT( M , 3 , N , 4 , IC , JC , DESCC , 14 , INFO )
068            IF( INFO.EQ.0 ) THEN
068                   
069                ICOFFA = MOD( JA - 1 , DESCA( NB_ ) )
070                IROFFC = MOD( IC - 1 , DESCC( MB_ ) )
071                ICOFFC = MOD( JC - 1 , DESCC( NB_ ) )
072                IACOL = INDXG2P( JA , DESCA( NB_ ) , MYCOL , DESCA( CSRC_ ) ,
073       $        NPCOL )
074                ICROW = INDXG2P( IC , DESCC( MB_ ) , MYROW , DESCC( RSRC_ ) ,
075       $        NPROW )
076                ICCOL = INDXG2P( JC , DESCC( NB_ ) , MYCOL , DESCC( CSRC_ ) ,
077       $        NPCOL )
078                MPC0 = NUMROC( M + IROFFC , DESCC( MB_ ) , MYROW , ICROW , NPROW )
079                NQC0 = NUMROC( N + ICOFFC , DESCC( NB_ ) , MYCOL , ICCOL , NPCOL )
080  
081                IF( LEFT ) THEN
081                       
082                    LCM = ILCM( NPROW , NPCOL )
083                    LCMP = LCM / NPROW
084                    LWMIN = MPC0 + MAX( MAX( 1 , NQC0 ) , NUMROC( NUMROC(
085       $            M + IROFFC , DESCA( MB_ ) , 0 , 0 , NPROW ) ,
086       $            DESCA( MB_ ) , 0 , 0 , LCMP ) )
087                ELSE
087                       
088                    NQC0 = NUMROC( N + ICOFFC , DESCC( NB_ ) , MYCOL , ICCOL ,
089       $            NPCOL )
090                    MPC0 = NUMROC( M + IROFFC , DESCC( MB_ ) , MYROW , ICROW ,
091       $            NPROW )
092                    LWMIN = NQC0 + MAX( 1 , MPC0 )
093                END IF
094  
095                WORK( 1 ) = CMPLX( REAL( LWMIN ) )
096                LQUERY =( LWORK.EQ. - 1 )
097                IF( .NOT.LEFT .AND. .NOT.LSAME( SIDE , 'R' ) ) THEN
097                       
098                    INFO = - 1
099                ELSE IF( .NOT.NOTRAN .AND. .NOT.LSAME( TRANS , 'C' ) ) THEN
099                       
100                    INFO = - 2
101                ELSE IF( K.LT.0 .OR. K.GT.NQ ) THEN
101                       
102                    INFO = - 5
103                ELSE IF( LEFT .AND. DESCA( NB_ ).NE.DESCC( MB_ ) ) THEN
103                       
104                    INFO = - (900 + NB_)
105                ELSE IF( LEFT .AND. ICOFFA.NE.IROFFC ) THEN
105                       
106                    INFO = - 12
107                ELSE IF( .NOT.LEFT .AND. ICOFFA.NE.ICOFFC ) THEN
107                       
108                    INFO = - 13
109                ELSE IF( .NOT.LEFT .AND. IACOL.NE.ICCOL ) THEN
109                       
110                    INFO = - 13
111                ELSE IF( .NOT.LEFT .AND. DESCA( NB_ ).NE.DESCC( NB_ ) ) THEN
111                       
112                    INFO = - (1400 + NB_)
113                ELSE IF( ICTXT.NE.DESCC( CTXT_ ) ) THEN
113                       
114                    INFO = - (1400 + CTXT_)
115                ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
115                       
116                    INFO = - 16
117                END IF
118            END IF
119        END IF
120  
121        IF( INFO.NE.0 ) THEN
121               
122            CALL PXERBLA( ICTXT , 'PCUNML2' , - INFO )
123            CALL BLACS_ABORT( ICTXT , 1 )
124            RETURN
125        ELSE IF( LQUERY ) THEN
125               
126            RETURN
127        END IF
128  
129  *     Quick return if possible
130  
131        IF( M.EQ.0 .OR. N.EQ.0 .OR. K.EQ.0 )
131               
132       $    RETURN
133  
134            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
135            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
136  
137            IF(( LEFT .AND. NOTRAN .OR. .NOT.LEFT .AND. .NOT.NOTRAN ) ) THEN
137                   
138                I1 = IA
139                I2 = IA + K - 1
140                I3 = 1
141            ELSE
141                   
142                I1 = IA + K - 1
143                I2 = IA
144                I3 = - 1
145            END IF
146  
147            IF( LEFT ) THEN
147                   
148                NI = N
149                JCC = JC
150            ELSE
150                   
151                MI = M
152                ICC = IC
153                CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , ' ' )
154                IF( NOTRAN ) THEN
154                       
155                    CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , 'D - ring' )
156                ELSE
156                       
157                    CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , 'I - ring' )
158                END IF
159            END IF
160  
161            DO 10 I = I1 , I2 , I3
161                   
162                IF( LEFT ) THEN
163  
164  *                 H(i) or H(i)' is applied to C(i : ic + m - 1 , jc : jc + n - 1)
165  
165                       
166                    MI = M - I + IA
167                    ICC = IC + I - IA
168                ELSE
169  
170  *                 H(i) or H(i)' is applied to C(ic : ic + m - 1 , jc + i - ia : jc + n - 1)
171  
171                       
172                    NI = N - I + IA
173                    JCC = JC + I - IA
174                END IF
175  
176  *             Apply H(i) or H(i)'
177  
178                IF( I - IA + 1.LT.NQ )
178                       
179       $            CALL PCLACGV ( NQ - I + IA - 1 , A , I , JA + I - IA + 1 , DESCA ,
180       $            DESCA( M_ ) )
181                    CALL PCELSET2( AII , A , I , JA + I - IA , DESCA , ONE )
182                    IF( NOTRAN ) THEN
182                           
183                        CALL PCLARFC ( SIDE , MI , NI , A , I , JA + I - IA , DESCA ,
184       $                DESCA( M_ ) , TAU , C , ICC , JCC , DESCC , WORK )
185                    ELSE
185                           
186                        CALL PCLARF ( SIDE , MI , NI , A , I , JA + I - IA , DESCA ,
187       $                DESCA( M_ ) , TAU , C , ICC , JCC , DESCC , WORK )
188                    END IF
189                    CALL PCELSET( A , I , JA + I - IA , DESCA , AII )
190                    IF( I - IA + 1.LT.NQ )
190                           
191       $                CALL PCLACGV ( NQ - I + IA - 1 , A , I , JA + I - IA + 1 , DESCA ,
192       $                DESCA( M_ ) )
193  
194     10     CONTINUE
195  
195               
196            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
197            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
198  
199            WORK( 1 ) = CMPLX( REAL( LWMIN ) )
200  
201            RETURN
202  
203  *         End of PCUNML2
204  
205        END2329

Variables in Routine PCUNML2()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	4	4
COMPLEX	2	8
INTEGER	48	192
LOGICAL	4	4
REAL	1	4
TOTAL	59	212

List of Variables

CHARACTER

COLBTOP ROWBTOP SIDE TRANS

COMPLEX

AII ONE

INTEGER

BLOCK_CYCLIC_2D CSRC_ CTXT_ DLEN_ DTYPE_
I I1 I2 I3 IA
IACOL IC ICC ICCOL ICOFFA
ICOFFC ICROW ICTXT ILCM INDXG2P
INFO IROFFC JA JC JCC
K LCM LCMP LLD_ LWMIN
LWORK M M_ MB_ MI
MPC0 MYCOL MYROW N N_
NB_ NI NPCOL NPROW NQ
NQC0 NUMROC RSRC_

LOGICAL

LEFT LQUERY LSAME NOTRAN

REAL

WORK

Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence
-
- -
I <--- I2DO 10 I = I1, I2, I3, I3DO 10 I = I1, I2, I3, I1DO 10 I = I1, I2, I3

I1 <--- IAI1 = IA{2I1 = IA + K -1}, KI1 = IA + K -1

I2 <--- IAI2 = IA + K - 1{2I2 = IA}, KI2 = IA + K - 1

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

ICC <--- IAICC = IC + I - IA, ICICC = IC{2ICC = IC + I - IA}, IICC = IC + I - IA

ICCOL <--- INDXG2P, JC, CSRC_, MYCOL, NB_, NPCOL

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

ICOFFC <--- JCICOFFC = MOD( JC-1, DESCC( NB_ ) ), NB_ICOFFC = MOD( JC-1, DESCC( NB_ ) )

ICROW <--- IC, INDXG2P, MB_, MYROW, NPROW, RSRC_

ICTXT <--- CTXT_ICTXT = DESCA( CTXT_ )

INFO <--- NB_INFO = -(900+NB_){2INFO = -(1400+NB_)}, CTXT_INFO = -(1400+CTXT_){2INFO = -(900+CTXT_)}

IROFFC <--- ICIROFFC = MOD( IC-1, DESCC( MB_ ) ), MB_IROFFC = MOD( IC-1, DESCC( MB_ ) )

JCC <--- IAJCC = JC + I - IA, JCJCC = JC{2JCC = JC + I - IA}, IJCC = JC + I - IA

LCM <--- ILCMLCM = ILCM( NPROW, NPCOL ), NPCOLLCM = ILCM( NPROW, NPCOL ), NPROWLCM = ILCM( NPROW, NPCOL )

LCMP <--- LCMLCMP = LCM / NPROW, NPROWLCMP = LCM / NPROW

LEFT <--- LSAMELEFT = LSAME( SIDE, 'L' ), SIDELEFT = LSAME( SIDE, 'L' )

LWMIN <--- IROFFC, LCMP, M, MB_, MPC0{2LWMIN = NQC0 + MAX( 1, MPC0 )}, NPROW, NQC0{2LWMIN = NQC0 + MAX( 1, MPC0 )}, NUMROC

MI <--- IAMI = M - I + IA, MMI = M{2MI = M - I + IA}, IMI = M - I + IA

MPC0 <--- ICROW{2}, IROFFC{2}, M{2}, MB_{2}, MYROW{2}, NPROW{2}, NUMROC{2}

NI <--- IANI = N - I + IA, NNI = N{2NI = N - I + IA}, INI = N - I + IA

NOTRAN <--- LSAMENOTRAN = LSAME( TRANS, 'N' ), NNOTRAN = LSAME( TRANS, 'N' ), TRANSNOTRAN = LSAME( TRANS, 'N' )

NQ <--- MNQ = M, NNQ = N

NQC0 <--- ICCOL{2}, ICOFFC{2}, MYCOL{2}, N{2}, NB_{2}, NPCOL{2}, NUMROC{2}

WORK <--- LWMINWORK( 1 ) = CMPLX( REAL( LWMIN ) ){2WORK( 1 ) = CMPLX( REAL( LWMIN ) )}

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

Assigned variables
		BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ , I , I1 , I2 , I3 , IACOL , ICC , ICCOL , ICOFFA , ICOFFC , ICROW , ICTXT , INFO , IROFFC , JCC , LCM , LCMP , LEFT , LLD_ , LQUERY , LWMIN , M_ , MB_ , MI , MPC0 , N_ , NB_ , NI , NOTRAN , NQ , NQC0 , ONE , RSRC_ , WORK

Active variables
		A , AII , BLOCK_CYCLIC_2D , C , COLBTOP , CSRC_ , CTXT_ , DESCA , DESCC , DLEN_ , DTYPE_ , I , I1 , I2 , I3 , IA , IACOL , IC , ICC , ICCOL , ICOFFA , ICOFFC , ICROW , ICTXT , ILCM , INDXG2P , INFO , IROFFC , JA , JC , JCC , K , LCM , LCMP , LEFT , LLD_ , LQUERY , LSAME , LWMIN , LWORK , M , M_ , MB_ , MI , MPC0 , MYCOL , MYROW , N , N_ , NB_ , NI , NOTRAN , NPCOL , NPROW , NQ , NQC0 , NUMROC , ONE , ROWBTOP , RSRC_ , SIDE , TAU , TRANS , WORK

Accessed arrays [ array name : associated index ]
	C	: i:ic+m-1,jc:jc+n-1 , ic:ic+m-1,jc+i-ia:jc+n-1
	DESCA	: CSRC_ , CTXT_ , M_ , M_ , M_ , M_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_
	DESCC	: CSRC_ , CTXT_ , MB_ , MB_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_ , NB_ , RSRC_
	ILCM	: NPROW, NPCOL
	LSAME	: SIDE, 'L' , SIDE, 'R' , TRANS, 'C' , TRANS, 'N'
	NUMROC	: M+IROFFC, DESCC( MB_ ), MYROW, ICROW, NPROW , N+ICOFFC, DESCC( NB_ ), MYCOL, ICCOL, NPCOL
	WORK	: 1 , 1

Conditional statements [ statement : associated predicate ]
	do	: `(` 10 I = I1 , I2 , I3 `)`
	if	: `(` NPROW.EQ. - 1 `)` , `(` LEFT `)` , `(` INFO.EQ.0 `)` , `(` LEFT `)` , `(` (.NOT.LEFT .AND. .NOT.LSAME( SIDE , 'R' ) ) `)` , `(` (.NOT.NOTRAN .AND. .NOT.LSAME( TRANS , 'C' ) ) `)` , `(` K.LT.0 .OR. K.GT.NQ `)` , `(` (LEFT .AND. DESCA( NB_ ).NE.DESCC( MB_ ) ) `)` , `(` LEFT .AND. ICOFFA.NE.IROFFC `)` , `(` .NOT.LEFT .AND. ICOFFA.NE.ICOFFC `)` , `(` .NOT.LEFT .AND. IACOL.NE.ICCOL `)` , `(` (.NOT.LEFT .AND. DESCA( NB_ ).NE.DESCC( NB_ ) ) `)` , `(` (ICTXT.NE.DESCC( CTXT_ ) ) `)` , `(` LWORK.LT.LWMIN .AND. .NOT.LQUERY `)` , `(` INFO.NE.0 `)` , `(` LQUERY `)` , `(` possible `)` , `(` M.EQ.0 .OR. N.EQ.0 .OR. K.EQ.0 `)` , `(` (( LEFT .AND. NOTRAN .OR. .NOT.LEFT .AND. .NOT.NOTRAN ) ) `)` , `(` LEFT `)` , `(` NOTRAN `)` , `(` LEFT `)` , `(` I-IA+1.LT.NQ `)` , `(` NOTRAN `)` , `(` I-IA+1.LT.NQ `)`