Routine PCUNMR2() Documented By Universal Report

Routine: PCUNMR2()

File: SRC\pcunmr2.f

# lines:	389
# code:	389
# comment:	0
# blank:	0
# Variables:	57
# Callers:	1
# Callings:	3
# Words:	211
# Keywords:	139

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

Variables in Routine PCUNMR2()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	4	4
COMPLEX	2	8
INTEGER	46	184
LOGICAL	4	4
REAL	1	4
TOTAL	57	204

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 ICCOL ICOFFA ICOFFC
ICROW ICTXT ILCM INDXG2P INFO
IROFFC JA JC 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

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 = -(1400+NB_){2INFO = -(900+NB_)}, CTXT_INFO = -(1400+CTXT_){2INFO = -(900+CTXT_)}

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

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 - K + I - IA + 1, KMI = M - K + I - IA + 1, MMI = M{2MI = M - K + I - IA + 1}, IMI = M - K + I - IA + 1

MPC0 <--- ICROW, IROFFC, M, MB_, MYROW, NPROW, NUMROC

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

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

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

NQC0 <--- ICCOL, ICOFFC, MYCOL, N, NB_, NPCOL, NUMROC

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

Analysis elements of the routine PCUNMR2()
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 , ICCOL , ICOFFA , ICOFFC , ICROW , ICTXT , INFO , IROFFC , 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 , ICCOL , ICOFFA , ICOFFC , ICROW , ICTXT , ILCM , INDXG2P , INFO , IROFFC , JA , JC , 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	: ic:ic+m-1,jc:jc+n-k+i-ia+1 , ic:ic+m-k+i-ia,jc:jc+n-1
	DESCA	: CSRC_ , CTXT_ , M_ , M_ , M_ , M_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_
	DESCC	: CSRC_ , CTXT_ , MB_ , MB_ , MB_ , MB_ , 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. .NOT.NOTRAN .OR. .NOT.LEFT .AND. NOTRAN ) ) `)` , `(` LEFT `)` , `(` NOTRAN `)` , `(` LEFT `)` , `(` NOTRAN `)`