Routine PDORMRZ() Documented By Universal Report

Routine: PDORMRZ()

# lines:	478
# code:	478
# comment:	0
# blank:	0
# Variables:	67
# Callers:	0
# Callings:	3
# Words:	267
# Keywords:	180

..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PDORMRZ overwrites the general real 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 = 'T':      Q**T * sub( C )       sub( C ) * Q**T
  where Q is a real orthogonal distributed matrix defined as the
  product of K elementary reflectors
        Q = H(1) H(2) . . . H(k)
  as returned by PDTZRZF. 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**T from the Left;
          = 'R': apply Q or Q**T from the Right.
  TRANS   (global input) CHARACTER
          = 'N':  No transpose, apply Q;
          = 'T':  Transpose, apply Q**T.
  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.
  L       (global input) INTEGER
          The columns of the distributed submatrix sub( A ) containing
          the meaningful part of the Householder reflectors.
          If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0.
  A       (local input) DOUBLE PRECISION 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 PDTZRZF 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) DOUBLE PRECISION array, dimension LOCc(IA+K-1).
          This array contains the scalar factors TAU(i) of the
          elementary reflectors H(i) as returned by PDTZRZF.
          TAU is tied to the distributed matrix A.
  C       (local input/local output) DOUBLE PRECISION 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) DOUBLE PRECISION 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 >= MAX( (MB_A*(MB_A-1))/2, ( MpC0 + MAX( MqA0 +
                     NUMROC( NUMROC( M+IROFFC, MB_A, 0, 0, NPROW ),
                             MB_A, 0, 0, LCMP ), NqC0 ) )*MB_A ) +
                     MB_A * MB_A
          else if SIDE = 'R',
            LWORK >= MAX( (MB_A*(MB_A-1))/2, (MpC0 + NqC0)*MB_A ) +
                     MB_A * MB_A
          end if
          where LCMP = LCM / NPROW with LCM = ICLM( NPROW, NPCOL ),
          IROFFA = MOD( IA-1, MB_A ), ICOFFA = MOD( JA-1, NB_A ),
          IACOL = INDXG2P( JA, NB_A, MYCOL, CSRC_A, NPCOL ),
          MqA0 = NUMROC( M+ICOFFA, NB_A, MYCOL, IACOL, 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    (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.
  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 PDORMRZ( SIDE , TRANS , M , N , K , L , A , IA , JA , DESCA ,
002       $TAU , 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 , L , 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  *     ..
018  *     .. Local Scalars ..
019        LOGICAL LEFT , LQUERY , NOTRAN
020        CHARACTER COLBTOP , ROWBTOP , TRANST
021        INTEGER I , I1 , I2 , I3 , IACOL , IB , ICC , ICCOL , ICOFFA ,
022       $ICOFFC , ICROW , ICTXT , IINFO , IPW , IROFFC , JAA ,
023       $JCC , LCM , LCMP , LWMIN , MI , MPC0 , MQA0 , MYCOL ,
024       $MYROW , NI , NPCOL , NPROW , NQ , NQC0
025  *     ..
026  *     .. Local Arrays ..
027        INTEGER IDUM1( 5 ) , IDUM2( 5 )
028  *     ..
029  *     .. External Subroutines ..
030        EXTERNAL BLACS_GRIDINFO , CHK1MAT , PCHK2MAT , PDLARZB ,
031       $PDLARZT , PDORMR3 , PB_TOPGET , PB_TOPSET , PXERBLA
032  *     ..
033  *     .. External Functions ..
034        LOGICAL LSAME
035        INTEGER ICEIL , ILCM , INDXG2P , NUMROC
036        EXTERNAL ICEIL , ILCM , INDXG2P , LSAME , NUMROC
037  *     ..
038  *     .. Intrinsic Functions ..
039        INTRINSIC DBLE , ICHAR , MAX , MIN , MOD
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 , 10 , INFO )
062            ELSE
062                   
063                NQ = N
064                CALL CHK1MAT( K , 5 , N , 4 , IA , JA , DESCA , 10 , INFO )
065            END IF
066            CALL CHK1MAT( M , 3 , N , 4 , IC , JC , DESCC , 15 , 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                    MQA0 = NUMROC( M + ICOFFA , DESCA( NB_ ) , MYCOL , IACOL ,
082       $            NPCOL )
083                    LCM = ILCM( NPROW , NPCOL )
084                    LCMP = LCM / NPROW
085                    LWMIN = MAX(( DESCA( MB_ ) * ( DESCA( MB_ ) - 1 ) )
086       $            / 2 ,( MPC0 + MAX( MQA0 + NUMROC( NUMROC(
087       $            M + IROFFC , DESCA( MB_ ) , 0 , 0 , NPROW ) ,
088       $            DESCA( MB_ ) , 0 , 0 , LCMP ) , NQC0 ) ) *
089       $            DESCA( MB_ ) ) + DESCA( MB_ ) * DESCA( MB_ )
090                ELSE
090                       
091                    LWMIN = MAX(( DESCA( MB_ ) * ( DESCA( MB_ ) - 1 ) ) / 2 ,
092       $( MPC0 + NQC0 ) * DESCA( MB_ ) ) +
092                       
093       $            DESCA( MB_ ) * DESCA( MB_ )
094                END IF
095  
096                WORK( 1 ) = DBLE( LWMIN )
097                LQUERY =( LWORK.EQ. - 1 )
098                IF( .NOT.LEFT .AND. .NOT.LSAME( SIDE , 'R' ) ) THEN
098                       
099                    INFO = - 1
100                ELSE IF( .NOT.NOTRAN .AND. .NOT.LSAME( TRANS , 'T' ) ) THEN
100                       
101                    INFO = - 2
102                ELSE IF( K.LT.0 .OR. K.GT.NQ ) THEN
102                       
103                    INFO = - 5
104                ELSE IF( K.LT.0 .OR. K.GT.NQ ) THEN
104                       
105                    INFO = - 6
106                ELSE IF( LEFT .AND. DESCA( NB_ ).NE.DESCC( MB_ ) ) THEN
106                       
107                    INFO = - (1000 + NB_)
108                ELSE IF( LEFT .AND. ICOFFA.NE.IROFFC ) THEN
108                       
109                    INFO = - 13
110                ELSE IF( .NOT.LEFT .AND. ICOFFA.NE.ICOFFC ) THEN
110                       
111                    INFO = - 14
112                ELSE IF( .NOT.LEFT .AND. IACOL.NE.ICCOL ) THEN
112                       
113                    INFO = - 14
114                ELSE IF( .NOT.LEFT .AND. DESCA( NB_ ).NE.DESCC( NB_ ) ) THEN
114                       
115                    INFO = - (1500 + NB_)
116                ELSE IF( ICTXT.NE.DESCC( CTXT_ ) ) THEN
116                       
117                    INFO = - (1500 + CTXT_)
118                ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
118                       
119                    INFO = - 17
120                END IF
121            END IF
122            IF( LEFT ) THEN
122                   
123                IDUM1( 1 ) = ICHAR( 'L' )
124            ELSE
124                   
125                IDUM1( 1 ) = ICHAR( 'R' )
126            END IF
127            IDUM2( 1 ) = 1
128            IF( NOTRAN ) THEN
128                   
129                IDUM1( 2 ) = ICHAR( 'N' )
130            ELSE
130                   
131                IDUM1( 2 ) = ICHAR( 'T' )
132            END IF
133            IDUM2( 2 ) = 2
134            IDUM1( 3 ) = K
135            IDUM2( 3 ) = 5
136            IDUM1( 4 ) = L
137            IDUM2( 4 ) = 6
138            IF( LWORK.EQ. - 1 ) THEN
138                   
139                IDUM1( 5 ) = - 1
140            ELSE
140                   
141                IDUM1( 5 ) = 1
142            END IF
143            IDUM2( 5 ) = 17
144            IF( LEFT ) THEN
144                   
145                CALL PCHK2MAT( K , 5 , M , 3 , IA , JA , DESCA , 10 , M , 3 , N , 4 ,
146       $        IC , JC , DESCC , 15 , 5 , IDUM1 , IDUM2 , INFO )
147            ELSE
147                   
148                CALL PCHK2MAT( K , 5 , N , 4 , IA , JA , DESCA , 10 , M , 3 , N , 4 ,
149       $        IC , JC , DESCC , 15 , 5 , IDUM1 , IDUM2 , INFO )
150            END IF
151        END IF
152  
153        IF( INFO.NE.0 ) THEN
153               
154            CALL PXERBLA( ICTXT , 'PDORMRZ' , - INFO )
155            RETURN
156        ELSE IF( LQUERY ) THEN
156               
157            RETURN
158        END IF
159  
160  *     Quick return if possible
161  
162        IF( M.EQ.0 .OR. N.EQ.0 .OR. K.EQ.0 )
162               
163       $    RETURN
164  
165            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
166            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
167  
168            IF(( LEFT .AND. .NOT.NOTRAN ) .OR.
169       $( .NOT.LEFT .AND. NOTRAN ) ) THEN
169               
170            I1 = MIN( ICEIL( IA , DESCA( MB_ ) ) * DESCA( MB_ ) , IA + K - 1 )
171       $    + 1
172            I2 = IA + K - 1
173            I3 = DESCA( MB_ )
174        ELSE
174               
175            I1 = MAX(((IA + K - 2) / DESCA( MB_ ) ) * DESCA( MB_ ) + 1 , IA )
176            I2 = MIN( ICEIL( IA , DESCA( MB_ ) ) * DESCA( MB_ ) , IA + K - 1 )
177       $    + 1
178            I3 = - DESCA( MB_ )
179        END IF
180  
181        IF( LEFT ) THEN
181               
182            NI = N
183            JCC = JC
184            JAA = JA + M - L
185        ELSE
185               
186            MI = M
187            ICC = IC
188            JAA = JA + N - L
189            CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , ' ' )
190            IF( NOTRAN ) THEN
190                   
191                CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , 'I - ring' )
192            ELSE
192                   
193                CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , 'D - ring' )
194            END IF
195        END IF
196  
197        IF( NOTRAN ) THEN
197               
198            TRANST = 'T'
199        ELSE
199               
200            TRANST = 'N'
201        END IF
202  
203        IF(( LEFT .AND. .NOT.NOTRAN ) .OR.
204       $( .NOT.LEFT .AND. NOTRAN ) ) THEN
205        IB = I1 - IA
206        IF( LEFT ) THEN
206               
207            MI = M
208        ELSE
208               
209            NI = N
210        END IF
211        CALL PDORMR3 ( SIDE , TRANS , MI , NI , IB , L , A , IA , JA , DESCA ,
212       $TAU , C , IC , JC , DESCC , WORK , LWORK , IINFO )
213        END IF
214  
215        IPW = DESCA( MB_ )*DESCA( MB_ ) + 1
216        DO 10 I = I1 , I2 , I3
216               
217            IB = MIN( DESCA( MB_ ) , K - I + IA )
218  
219  *         Form the triangular factor of the block reflector
220  *         H = H(i + ib - 1) . . . H(i + 1) H(i)
221  
222            CALL PDLARZT ( 'Backward' , 'Rowwise' , L , IB , A , I , JAA , DESCA ,
223       $    TAU , WORK , WORK( IPW ) )
224            IF( LEFT ) THEN
225  
226  *             H or H' is applied to C(ic + i - ia : ic + m - 1 , jc : jc + n - 1)
227  
227                   
228                MI = M - I + IA
229                ICC = IC + I - IA
230            ELSE
231  
232  *             H or H' is applied to C(ic : ic + m - 1 , jc + i - ia : jc + n - 1)
233  
233                   
234                NI = N - I + IA
235                JCC = JC + I - IA
236            END IF
237  
238  *         Apply H or H'
239  
240            CALL PDLARZB ( SIDE , TRANST , 'Backward' , 'Rowwise' , MI , NI , IB ,
241       $    L , A , I , JAA , DESCA , WORK , C , ICC , JCC , DESCC ,
242       $    WORK( IPW ) )
243     10 CONTINUE
244  
245        IF(( LEFT .AND. .NOT.NOTRAN ) .OR.
246       $( .NOT.LEFT .AND. NOTRAN ) ) THEN
247        IB = I2 - IA
248        IF( LEFT ) THEN
248               
249            MI = M
250        ELSE
250               
251            NI = N
252        END IF
253        CALL PDORMR3 ( SIDE , TRANS , MI , NI , IB , L , A , IA , JA , DESCA ,
254       $TAU , C , IC , JC , DESCC , WORK , LWORK , IINFO )
255        END IF
256  
257        CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
258        CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
259  
260        WORK( 1 ) = DBLE( LWMIN )
261  
262        RETURN
263  
264  *     End of PDORMRZ
265  
266        END2733

Variables in Routine PDORMRZ()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	5	5
INTEGER	57	264
LOGICAL	4	4
REAL	1	4
TOTAL	67	277

List of Variables

CHARACTER

COLBTOP ROWBTOP SIDE TRANS TRANST

INTEGER

BLOCK_CYCLIC_2D CSRC_ CTXT_ DLEN_ DTYPE_
I I1 I2 I3 IA
IACOL IB IC ICC ICCOL
ICEIL ICOFFA ICOFFC ICROW ICTXT
IDUM1( 5 ) IDUM2( 5 ) IINFO ILCM INDXG2P
INFO IPW IROFFC JA JAA
JC JCC K L LCM
LCMP LLD_ LWMIN LWORK M
M_ MB_ MI MPC0 MQA0
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 <--- I3DO 10 I = I1, I2, I3, I1DO 10 I = I1, I2, I3, I2DO 10 I = I1, I2, I3

I1 <--- IA{2}, ICEIL, K{2}, MB_{2}

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

I3 <--- MB_I3 = DESCA( MB_ ){2I3 = -DESCA( MB_ )}

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

IB <--- IAIB = I1 - IA{2IB = MIN( DESCA( MB_ ), K-I+IA ), 3IB = I2 - IA}, KIB = MIN( DESCA( MB_ ), K-I+IA ), MB_IB = MIN( DESCA( MB_ ), K-I+IA ), IIB = MIN( DESCA( MB_ ), K-I+IA ), I1IB = I1 - IA, I2IB = I2 - IA

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

ICCOL <--- INDXG2P, CSRC_, JC, 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_ )

IDUM1 <--- KIDUM1( 3 ) = K, LIDUM1( 1 ) = ICHAR( 'L' ){2IDUM1( 4 ) = L}, NIDUM1( 2 ) = ICHAR( 'N' )

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

IPW <--- MB_IPW = DESCA( MB_ )*DESCA( MB_ ) + 1

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

JAA <--- JAJAA = JA + M - L{2JAA = JA + N - L}, LJAA = JA + M - L{2JAA = JA + N - L}, MJAA = JA + M - L, NJAA = JA + N - L

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 <--- LLEFT = LSAME( SIDE, 'L' ), LSAMELEFT = LSAME( SIDE, 'L' ), SIDELEFT = LSAME( SIDE, 'L' )

LWMIN <--- IROFFC, LCMP, M, MB_{2}, MPC0{2}, MQA0, NPROW, NQC0{2}, NUMROC

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

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

MQA0 <--- IACOL, ICOFFA, M, MYCOL, NB_, NPCOL, NUMROC

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

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

TRANST <--- NTRANST = 'N'

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

Analysis elements of the routine PDORMRZ()
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 , IB , ICC , ICCOL , ICOFFA , ICOFFC , ICROW , ICTXT , IDUM1 , IDUM2 , INFO , IPW , IROFFC , JAA , JCC , LCM , LCMP , LEFT , LLD_ , LQUERY , LWMIN , M_ , MB_ , MI , MPC0 , MQA0 , N_ , NB_ , NI , NOTRAN , NQ , NQC0 , RSRC_ , TRANST , WORK

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

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

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 , 'T' ) ) `)` , `(` K.LT.0 .OR. K.GT.NQ `)` , `(` 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 `)` , `(` LEFT `)` , `(` NOTRAN `)` , `(` LWORK.EQ. - 1 `)` , `(` LEFT `)` , `(` INFO.NE.0 `)` , `(` LQUERY `)` , `(` possible `)` , `(` M.EQ.0 .OR. N.EQ.0 .OR. K.EQ.0 `)` , `(` (( LEFT .AND. .NOT.NOTRAN ) .OR. `)` , `(` LEFT `)` , `(` NOTRAN `)` , `(` NOTRAN `)` , `(` (( LEFT .AND. .NOT.NOTRAN ) .OR. `)` , `(` LEFT `)` , `(` LEFT `)` , `(` (( LEFT .AND. .NOT.NOTRAN ) .OR. `)` , `(` LEFT `)`