Routine PZGEEQU() Documented By Universal Report

Routine: PZGEEQU()

File: SRC\pzgeequ.f

# lines:	375
# code:	375
# comment:	0
# blank:	0
# Variables:	54
# Callers:	1
# Callings:	1
# Words:	173
# Keywords:	99

..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PZGEEQU computes row and column scalings intended to equilibrate an
  M-by-N distributed matrix sub( A ) = A(IA:IA+N-1,JA:JA:JA+N-1) and
  reduce its condition number.  R returns the row scale factors and C
  the column scale factors, chosen to try to make the largest entry in
  each row and column of the distributed matrix B with elements
  B(i,j) = R(i) * A(i,j) * C(j) have absolute value 1.
  R(i) and C(j) are restricted to be between SMLNUM = smallest safe
  number and BIGNUM = largest safe number.  Use of these scaling
  factors is not guaranteed to reduce the condition number of
  sub( A ) but works well in practice.
  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
  =========
  M       (global input) INTEGER
          The number of rows to be operated on i.e the number of rows
          of the distributed submatrix sub( A ). 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( A ). N >= 0.
  A       (local input) COMPLEX*16 pointer into the local memory
          to an array of dimension ( LLD_A, LOCc(JA+N-1) ), the
          local pieces of the M-by-N distributed matrix whose
          equilibration factors are to be computed.
  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.
  R       (local output) DOUBLE PRECISION array, dimension LOCr(M_A)
          If INFO = 0 or INFO > IA+M-1, R(IA:IA+M-1) contains the row
          scale factors for sub( A ). R is aligned with the distributed
          matrix A, and replicated across every process column. R is
          tied to the distributed matrix A.
  C       (local output) DOUBLE PRECISION array, dimension LOCc(N_A)
          If INFO = 0,  C(JA:JA+N-1) contains the column scale factors
          for sub( A ). C is aligned with the distributed matrix A, and
          replicated down every process row. C is tied to the distri-
          buted matrix A.
  ROWCND  (global output) DOUBLE PRECISION
          If INFO = 0 or INFO > IA+M-1, ROWCND contains the ratio of
          the smallest R(i) to the largest R(i) (IA <= i <= IA+M-1).
          If ROWCND >= 0.1 and AMAX is neither too large nor too small,
          it is not worth scaling by R(IA:IA+M-1).
  COLCND  (global output) DOUBLE PRECISION
          If INFO = 0, COLCND contains the ratio of the smallest C(j)
          to the largest C(j) (JA <= j <= JA+N-1). If COLCND >= 0.1, it
          is not worth scaling by C(JA:JA+N-1).
  AMAX    (global output) DOUBLE PRECISION
          Absolute value of largest distributed matrix element.  If
          AMAX is very close to overflow or very close to underflow,
          the matrix should be scaled.
  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.
          > 0:  If INFO = i,  and i is
                <= M:  the i-th row of the distributed matrix sub( A )
                       is exactly zero,
                >  M:  the (i-M)-th column of the distributed
                       matrix sub( A ) is exactly zero.
  =====================================================================
     .. Parameters ..

Display dynamic version

FontSize: - +

001        SUBROUTINE PZGEEQU( M , N , A , IA , JA , DESCA , R , C , ROWCND , COLCND ,
002       $AMAX , 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        INTEGER IA , INFO , JA , M , N
011        DOUBLE PRECISION AMAX , COLCND , ROWCND
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        DOUBLE PRECISION ONE , ZERO
018        PARAMETER( ONE = 1.0D + 0 , ZERO = 0.0D + 0 )
019  *     ..
020  *     .. Local Scalars ..
021        CHARACTER COLCTOP , ROWCTOP
022        INTEGER I , IACOL , IAROW , ICOFF , ICTXT , IDUMM , IIA ,
023       $IOFFA , IROFF , J , JJA , LDA , MP , MYCOL , MYROW ,
024       $NPCOL , NPROW , NQ
025        DOUBLE PRECISION BIGNUM , RCMAX , RCMIN , SMLNUM
026        COMPLEX*16 ZDUM
027  *     ..
028  *     .. Local Arrays ..
029        INTEGER DESCC( DLEN_ ) , DESCR( DLEN_ )
030  *     ..
031  *     .. External Subroutines ..
032        EXTERNAL BLACS_GRIDINFO , CHK1MAT , DESCSET , DGAMN2D ,
033       $DGAMX2D , IGAMX2D , INFOG2L , PCHK1MAT , PB_TOPGET ,
034       $PXERBLA
035  *     ..
036  *     .. External Functions ..
037        INTEGER INDXL2G , NUMROC
038        DOUBLE PRECISION PDLAMCH
039        EXTERNAL INDXL2G , NUMROC , PDLAMCH
040  *     ..
041  *     .. Intrinsic Functions ..
042        INTRINSIC ABS , DBLE , DIMAG , MAX , MIN , MOD
043  *     ..
044  *     .. Statement Functions ..
045        DOUBLE PRECISION ZABS1
046  *     ..
047  *     .. Statement Function definitions ..
048        ZABS1( ZDUM ) = ABS( DBLE( ZDUM ) ) + ABS( DIMAG( ZDUM ) )
049  *     ..
050  *     .. Executable Statements ..
051  
052  *     Get grid parameters
053  
054        ICTXT = DESCA( CTXT_ )
055        CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
056  
057  *     Test the input parameters.
058  
059        INFO = 0
060        IF( NPROW.EQ. - 1 ) THEN
060               
061            INFO = - (600 + CTXT_)
062        ELSE
062               
063            CALL CHK1MAT( M , 1 , N , 2 , IA , JA , DESCA , 6 , INFO )
064            CALL PCHK1MAT( M , 1 , N , 2 , IA , JA , DESCA , 6 , 0 , IDUMM , IDUMM ,
065       $    INFO )
066        END IF
067  
068        IF( INFO.NE.0 ) THEN
068               
069            CALL PXERBLA( ICTXT , 'PZGEEQU' , - INFO )
070            RETURN
071        END IF
072  
073  *     Quick return if possible
074  
075        IF( M.EQ.0 .OR. N.EQ.0 ) THEN
075               
076            ROWCND = ONE
077            COLCND = ONE
078            AMAX = ZERO
079            RETURN
080        END IF
081  
082        CALL PB_TOPGET( ICTXT , 'Combine' , 'Rowwise' , ROWCTOP )
083        CALL PB_TOPGET( ICTXT , 'Combine' , 'Columnwise' , COLCTOP )
084  
085  *     Get machine constants and local indexes.
086  
087        SMLNUM = PDLAMCH( ICTXT , 'S' )
088        BIGNUM = ONE / SMLNUM
089        CALL INFOG2L( IA , JA , DESCA , NPROW , NPCOL , MYROW , MYCOL , IIA , JJA ,
090       $IAROW , IACOL )
091        IROFF = MOD( IA - 1 , DESCA( MB_ ) )
092        ICOFF = MOD( JA - 1 , DESCA( NB_ ) )
093        MP = NUMROC( M + IROFF , DESCA( MB_ ) , MYROW , IAROW , NPROW )
094        NQ = NUMROC( N + ICOFF , DESCA( NB_ ) , MYCOL , IACOL , NPCOL )
095        IF( MYROW.EQ.IAROW )
095               
096       $    MP = MP - IROFF
097            IF( MYCOL.EQ.IACOL )
097                   
098       $        NQ = NQ - ICOFF
099                LDA = DESCA( LLD_ )
100  
101  *             Assign descriptors for R and C arrays
102  
103                CALL DESCSET( DESCR , M , 1 , DESCA( MB_ ) , 1 , 0 , 0 , ICTXT ,
104       $        MAX( 1 , MP ) )
105                CALL DESCSET( DESCC , 1 , N , 1 , DESCA( NB_ ) , 0 , 0 , ICTXT , 1 )
106  
107  *             Compute row scale factors.
108  
109                DO 10 I = IIA , IIA + MP - 1
109                       
110                    R( I ) = ZERO
111     10         CONTINUE
112  
113  *             Find the maximum element in each row.
114  
114                   
115                IOFFA =(JJA - 1)*LDA
116                DO 30 J = JJA , JJA + NQ - 1
116                       
117                    DO 20 I = IIA , IIA + MP - 1
117                           
118                        R( I ) = MAX( R( I ) , ZABS1( A( IOFFA + I ) ) )
119     20             CONTINUE
119                       
120                    IOFFA = IOFFA + LDA
121     30         CONTINUE
121                   
122                CALL DGAMX2D( ICTXT , 'Rowwise' , ROWCTOP , MP , 1 , R( IIA ) ,
123       $        MAX( 1 , MP ) , IDUMM , IDUMM , - 1 , - 1 , MYCOL )
124  
125  *             Find the maximum and minimum scale factors.
126  
127                RCMIN = BIGNUM
128                RCMAX = ZERO
129                DO 40 I = IIA , IIA + MP - 1
129                       
130                    RCMAX = MAX( RCMAX , R( I ) )
131                    RCMIN = MIN( RCMIN , R( I ) )
132     40         CONTINUE
132                   
133                CALL DGAMX2D( ICTXT , 'Columnwise' , COLCTOP , 1 , 1 , RCMAX , 1 , IDUMM ,
134       $        IDUMM , - 1 , - 1 , MYCOL )
135                CALL DGAMN2D( ICTXT , 'Columnwise' , COLCTOP , 1 , 1 , RCMIN , 1 , IDUMM ,
136       $        IDUMM , - 1 , - 1 , MYCOL )
137                AMAX = RCMAX
138  
139                IF( RCMIN.EQ.ZERO ) THEN
140  
141  *                 Find the first zero scale factor and return an error code.
142  
142                       
143                    DO 50 I = IIA , IIA + MP - 1
143                           
144                        IF( R( I ).EQ.ZERO .AND. INFO.EQ.0 )
144                               
145       $                    INFO = INDXL2G( I , DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) ,
146       $                    NPROW ) - IA + 1
147     50             CONTINUE
147                       
148                    CALL IGAMX2D( ICTXT , 'Columnwise' , COLCTOP , 1 , 1 , INFO , 1 ,
149       $            IDUMM , IDUMM , - 1 , - 1 , MYCOL )
150                    IF( INFO.NE.0 )
150                           
151       $                RETURN
152                    ELSE
153  
154  *                     Invert the scale factors.
155  
155                           
156                        DO 60 I = IIA , IIA + MP - 1
156                               
157                            R( I ) = ONE / MIN( MAX( R( I ) , SMLNUM ) , BIGNUM )
158     60                 CONTINUE
159  
160  *                     Compute ROWCND = min(R(I)) / max(R(I))
161  
161                           
162                        ROWCND = MAX( RCMIN , SMLNUM ) / MIN( RCMAX , BIGNUM )
163  
164                    END IF
165  
166  *                 Compute column scale factors
167  
168                    DO 70 J = JJA , JJA + NQ - 1
168                           
169                        C( J ) = ZERO
170     70             CONTINUE
171  
172  *                 Find the maximum element in each column ,
173  *                 assuming the row scaling computed above.
174  
174                       
175                    IOFFA =(JJA - 1)*LDA
176                    DO 90 J = JJA , JJA + NQ - 1
176                           
177                        DO 80 I = IIA , IIA + MP - 1
177                               
178                            C( J ) = MAX( C( J ) , ZABS1( A( IOFFA + I ) )*R( I ) )
179     80                 CONTINUE
179                           
180                        IOFFA = IOFFA + LDA
181     90             CONTINUE
181                       
182                    CALL DGAMX2D( ICTXT , 'Columnwise' , COLCTOP , 1 , NQ , C( JJA ) ,
183       $            1 , IDUMM , IDUMM , - 1 , - 1 , MYCOL )
184  
185  *                 Find the maximum and minimum scale factors.
186  
187                    RCMIN = BIGNUM
188                    RCMAX = ZERO
189                    DO 100 J = JJA , JJA + NQ - 1
189                           
190                        RCMIN = MIN( RCMIN , C( J ) )
191                        RCMAX = MAX( RCMAX , C( J ) )
192    100             CONTINUE
192                       
193                    CALL DGAMX2D( ICTXT , 'Columnwise' , COLCTOP , 1 , 1 , RCMAX , 1 , IDUMM ,
194       $            IDUMM , - 1 , - 1 , MYCOL )
195                    CALL DGAMN2D( ICTXT , 'Columnwise' , COLCTOP , 1 , 1 , RCMIN , 1 , IDUMM ,
196       $            IDUMM , - 1 , - 1 , MYCOL )
197  
198                    IF( RCMIN.EQ.ZERO ) THEN
199  
200  *                     Find the first zero scale factor and return an error code.
201  
201                           
202                        DO 110 J = JJA , JJA + NQ - 1
202                               
203                            IF( C( J ).EQ.ZERO .AND. INFO.EQ.0 )
203                                   
204       $                        INFO = M + INDXL2G( J , DESCA( NB_ ) , MYCOL ,
205       $                        DESCA( CSRC_ ) , NPCOL ) - JA + 1
206    110                 CONTINUE
206                           
207                        CALL IGAMX2D( ICTXT , 'Columnwise' , COLCTOP , 1 , 1 , INFO , 1 ,
208       $                IDUMM , IDUMM , - 1 , - 1 , MYCOL )
209                        IF( INFO.NE.0 )
209                               
210       $                    RETURN
211                        ELSE
212  
213  *                         Invert the scale factors.
214  
214                               
215                            DO 120 J = JJA , JJA + NQ - 1
215                                   
216                                C( J ) = ONE / MIN( MAX( C( J ) , SMLNUM ) , BIGNUM )
217    120                     CONTINUE
218  
219  *                         Compute COLCND = min(C(J)) / max(C(J))
220  
220                               
221                            COLCND = MAX( RCMIN , SMLNUM ) / MIN( RCMAX , BIGNUM )
222  
223                        END IF
224  
225                        RETURN
226  
227  *                     End of PZGEEQU
228  
229                    END4045

Variables in Routine PZGEEQU()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	2	2
*COMPLEX16**	1	?
DOUBLE PRECISION	11	44
INTEGER	38	152
REAL	2	8
TOTAL	54	206

List of Variables

CHARACTER

COLCTOP ROWCTOP

COMPLEX*16

ZDUM

DOUBLE PRECISION

AMAX BIGNUM COLCND ONE PDLAMCH
RCMAX RCMIN ROWCND SMLNUM ZABS1
ZERO

INTEGER

BLOCK_CYCLIC_2D CSRC_ CTXT_ DESCC( DLEN_ ) DESCR( DLEN_ )
DLEN_ DTYPE_ I IA IACOL
IAROW ICOFF ICTXT IDUMM IIA
INDXL2G INFO IOFFA IROFF J
JA JJA LDA LLD_ M
M_ MB_ MP MYCOL MYROW
N N_ NB_ NPCOL NPROW
NQ NUMROC RSRC_

REAL

C R

Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence
-
- -
AMAX <--- RCMAXAMAX = RCMAX, ZEROAMAX = ZERO

BIGNUM <--- ONEBIGNUM = ONE / SMLNUM, SMLNUMBIGNUM = ONE / SMLNUM

C <--- I, BIGNUM, IOFFA, J{2}, C{2}, ONE, R, SMLNUM, ZABS1, ZEROC( J ) = ZERO

COLCND <--- BIGNUM, ONECOLCND = ONE, RCMAX, RCMIN, SMLNUM

I <--- IIADO 10 I = IIA, IIA+MP-1{2DO 20 I = IIA, IIA+MP-1, 3DO 40 I = IIA, IIA+MP-1, 4DO 50 I = IIA, IIA+MP-1, 5DO 60 I = IIA, IIA+MP-1, 6DO 80 I = IIA, IIA+MP-1}, MPDO 10 I = IIA, IIA+MP-1{2DO 20 I = IIA, IIA+MP-1, 3DO 40 I = IIA, IIA+MP-1, 4DO 50 I = IIA, IIA+MP-1, 5DO 60 I = IIA, IIA+MP-1, 6DO 80 I = IIA, IIA+MP-1}

ICOFF <--- JAICOFF = MOD( JA-1, DESCA( NB_ ) ), NB_ICOFF = MOD( JA-1, DESCA( NB_ ) )

ICTXT <--- CTXT_ICTXT = DESCA( CTXT_ )

INFO <--- CTXT_INFO = -(600+CTXT_)

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

IROFF <--- IAIROFF = MOD( IA-1, DESCA( MB_ ) ), MB_IROFF = MOD( IA-1, DESCA( MB_ ) )

J <--- JJADO 30 J = JJA, JJA+NQ-1{2DO 70 J = JJA, JJA+NQ-1, 3DO 90 J = JJA, JJA+NQ-1, 4DO 100 J = JJA, JJA+NQ-1, 5DO 110 J = JJA, JJA+NQ-1, 6DO 120 J = JJA, JJA+NQ-1}, NQDO 30 J = JJA, JJA+NQ-1{2DO 70 J = JJA, JJA+NQ-1, 3DO 90 J = JJA, JJA+NQ-1, 4DO 100 J = JJA, JJA+NQ-1, 5DO 110 J = JJA, JJA+NQ-1, 6DO 120 J = JJA, JJA+NQ-1}

LDA <--- LLD_LDA = DESCA( LLD_ )

MP <--- IAROW, IROFF, M, MB_, MYROW, NPROW, NUMROC

NQ <--- IACOL, ICOFF, MYCOL, N, NB_, NPCOL, NUMROC

R <--- I{2}, BIGNUM, IOFFA, ONE, R{2}, SMLNUM, ZABS1, ZEROR( I ) = ZERO

RCMAX <--- IRCMAX = MAX( RCMAX, R( I ) ), JRCMAX = MAX( RCMAX, C( J ) ), CRCMAX = MAX( RCMAX, C( J ) ), RRCMAX = MAX( RCMAX, R( I ) ), RCMAXRCMAX = MAX( RCMAX, R( I ) ){2RCMAX = MAX( RCMAX, C( J ) )}, ZERORCMAX = ZERO{2RCMAX = ZERO}

RCMIN <--- IRCMIN = MIN( RCMIN, R( I ) ), BIGNUMRCMIN = BIGNUM{2RCMIN = BIGNUM}, JRCMIN = MIN( RCMIN, C( J ) ), CRCMIN = MIN( RCMIN, C( J ) ), RRCMIN = MIN( RCMIN, R( I ) ), RCMINRCMIN = MIN( RCMIN, R( I ) ){2RCMIN = MIN( RCMIN, C( J ) )}

ROWCND <--- BIGNUM, ONEROWCND = ONE, RCMAX, RCMIN, SMLNUM

SMLNUM <--- ICTXTSMLNUM = PDLAMCH( ICTXT, 'S' ), PDLAMCHSMLNUM = PDLAMCH( ICTXT, 'S' )

ZABS1 <--- ZDUM

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

Assigned variables
		AMAX , BIGNUM , BLOCK_CYCLIC_2D , COLCND , CSRC_ , CTXT_ , DLEN_ , DTYPE_ , I , ICOFF , ICTXT , INFO , IOFFA , IROFF , J , LDA , LLD_ , M_ , MB_ , MP , N_ , NB_ , NQ , ONE , RCMAX , RCMIN , ROWCND , RSRC_ , SMLNUM , ZDUM , ZERO

Active variables
		A , AMAX , BIGNUM , BLOCK_CYCLIC_2D , C , COLCND , COLCTOP , CSRC_ , CTXT_ , DESCA , DESCC , DESCR , DLEN_ , DTYPE_ , I , IA , IACOL , IAROW , ICOFF , ICTXT , IDUMM , IIA , INDXL2G , INFO , IOFFA , IROFF , J , JA , JJA , LDA , LLD_ , M , M_ , MB_ , MP , MYCOL , MYROW , N , N_ , NB_ , NPCOL , NPROW , NQ , NUMROC , ONE , PDLAMCH , R , RCMAX , RCMIN , ROWCND , ROWCTOP , RSRC_ , SMLNUM , ZABS1 , ZDUM , ZERO

Accessed arrays [ array name : associated index ]
	A	: IOFFA + I , IOFFA + I
	C	: J , J , J , J , J , J , J , JJA
	DESCA	: CSRC_ , CTXT_ , LLD_ , MB_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_ , RSRC_
	DESCC	: DLEN_
	DESCR	: DLEN_
	NUMROC	: M+IROFF, DESCA( MB_ ), MYROW, IAROW, NPROW , N+ICOFF, DESCA( NB_ ), MYCOL, IACOL, NPCOL
	PDLAMCH	: ICTXT, 'S'
	R	: I , I , I , I , I , I , I , I , IIA
	ZABS1	: A( IOFFA + I ) , A( IOFFA + I ) , ZDUM

Conditional statements [ statement : associated predicate ]
	do	: `(` 10 I = IIA , IIA + MP - 1 `)` , `(` 30 J = JJA , JJA + NQ - 1 `)` , `(` 20 I = IIA , IIA + MP - 1 `)` , `(` 40 I = IIA , IIA + MP - 1 `)` , `(` 50 I = IIA , IIA + MP - 1 `)` , `(` 60 I = IIA , IIA + MP - 1 `)` , `(` 70 J = JJA , JJA + NQ - 1 `)` , `(` 90 J = JJA , JJA + NQ - 1 `)` , `(` 80 I = IIA , IIA + MP - 1 `)` , `(` 100 J = JJA , JJA + NQ - 1 `)` , `(` 110 J = JJA , JJA + NQ - 1 `)` , `(` 120 J = JJA , JJA + NQ - 1 `)`
	for	: `(` R and C arrays `)`
	if	: `(` NPROW.EQ. - 1 `)` , `(` INFO.NE.0 `)` , `(` possible `)` , `(` M.EQ.0 .OR. N.EQ.0 `)` , `(` MYROW.EQ.IAROW `)` , `(` MYCOL.EQ.IACOL `)` , `(` RCMIN.EQ.ZERO `)` , `(` (R( I ).EQ.ZERO .AND. INFO.EQ.0 ) `)` , `(` INFO.NE.0 `)` , `(` RCMIN.EQ.ZERO `)` , `(` (C( J ).EQ.ZERO .AND. INFO.EQ.0 ) `)` , `(` INFO.NE.0 `)`