Routine PSGEEQU() Documented By Universal Report

Routine: PSGEEQU()

File: SRC\psgeequ.f

# lines:	367
# code:	367
# comment:	0
# blank:	0
# Variables:	52
# Callers:	1
# Callings:	1
# Words:	162
# Keywords:	97

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

Variables in Routine PSGEEQU()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	2	2
INTEGER	38	152
REAL	12	48
TOTAL	52	202

List of Variables

CHARACTER

COLCTOP ROWCTOP

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

AMAX BIGNUM C COLCND ONE
PSLAMCH R RCMAX RCMIN ROWCND
SMLNUM ZERO

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, 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, 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 = PSLAMCH( ICTXT, 'S' ), PSLAMCHSMLNUM = PSLAMCH( ICTXT, 'S' )

Analysis elements of the routine PSGEEQU()
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 , 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 , PSLAMCH , R , RCMAX , RCMIN , ROWCND , ROWCTOP , RSRC_ , SMLNUM , 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
	PSLAMCH	: ICTXT, 'S'
	R	: I , I , I , I , I , I , I , I , IIA

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 `)`