Routine PZUNMQL() Documented By Universal Report

Routine: PZUNMQL()

File: SRC\pzunmql.f

# lines:	459
# code:	459
# comment:	0
# blank:	0
# Variables:	62
# Callers:	1
# Callings:	3
# Words:	258
# Keywords:	172

..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PZUNMQL 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 PZGEQLF. 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*16 pointer into the local memory
          to an array of dimension (LLD_A,LOCc(JA+K-1)). On entry, the
          j-th column must contain the vector which defines the elemen-
          tary reflector H(j), JA <= j <= JA+K-1, as returned by
          PZGEQLF in the K columns of its distributed matrix
          argument A(IA:*,JA:JA+K-1). A(IA:*,JA:JA+K-1) is modified by
          the routine but restored on exit.
          If SIDE = 'L', LLD_A >= MAX( 1, LOCr(IA+M-1) ),
          if SIDE = 'R', LLD_A >= MAX( 1, LOCr(IA+N-1) ).
  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*16, array, dimension LOCc(JA+N-1)
          This array contains the scalar factors TAU(j) of the
          elementary reflectors H(j) as returned by PZGEQLF.
          TAU is tied to the distributed matrix A.
  C       (local input/local output) COMPLEX*16 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*16 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( (NB_A*(NB_A-1))/2, (NqC0 + MpC0)*NB_A ) +
                     NB_A * NB_A
          else if SIDE = 'R',
            LWORK >= MAX( (NB_A*(NB_A-1))/2, ( NqC0 + MAX( NpA0 +
                     NUMROC( NUMROC( N+ICOFFC, NB_A, 0, 0, NPCOL ),
                             NB_A, 0, 0, LCMQ ), MpC0 ) )*NB_A ) +
                     NB_A * NB_A
          end if
          where LCMQ = LCM / NPCOL with LCM = ICLM( NPROW, NPCOL ),
          IROFFA = MOD( IA-1, MB_A ), ICOFFA = MOD( JA-1, NB_A ),
          IAROW = INDXG2P( IA, MB_A, MYROW, RSRC_A, NPROW ),
          NpA0 = NUMROC( N+IROFFA, MB_A, MYROW, IAROW, NPROW ),
          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',
    ( MB_A.EQ.MB_C .AND. IROFFA.EQ.IROFFC .AND. IAROW.EQ.ICROW )
  If SIDE = 'R',
    ( MB_A.EQ.NB_C .AND. IROFFA.EQ.ICOFFC )
  =====================================================================
     .. Parameters ..

Display dynamic version

FontSize: - +

001        SUBROUTINE PZUNMQL( 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  *     ..
018  *     .. Local Scalars ..
019        LOGICAL LEFT , LQUERY , NOTRAN
020        CHARACTER COLBTOP , ROWBTOP
021        INTEGER IAROW , ICCOL , ICOFFC , ICROW , ICTXT , IINFO , IPW ,
022       $IROFFA , IROFFC , J , J1 , J2 , J3 , JB , LCM , LCMQ ,
023       $LWMIN , MI , MPC0 , MYCOL , MYROW , NI , NPA0 , NPCOL ,
024       $NPROW , NQ , NQC0
025  *     ..
026  *     .. Local Arrays ..
027        INTEGER IDUM1( 4 ) , IDUM2( 4 )
028  *     ..
029  *     .. External Subroutines ..
030        EXTERNAL BLACS_GRIDINFO , CHK1MAT , PCHK2MAT , PB_TOPGET ,
031       $PB_TOPSET , PXERBLA , PZLARFB , PZLARFT ,
032       $PZUNM2L  
033  *     ..
034  *     .. External Functions ..
035        LOGICAL LSAME
036        INTEGER ICEIL , ILCM , INDXG2P , NUMROC
037        EXTERNAL ICEIL , ILCM , INDXG2P , LSAME , NUMROC
038  *     ..
039  *     .. Intrinsic Functions ..
040        INTRINSIC DBLE , DCMPLX , ICHAR , MAX , MIN , MOD
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( M , 3 , K , 5 , IA , JA , DESCA , 9 , INFO )
063            ELSE
063                   
064                NQ = N
065                CALL CHK1MAT( N , 4 , K , 5 , 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                IROFFA = MOD( IA - 1 , DESCA( MB_ ) )
070                IROFFC = MOD( IC - 1 , DESCC( MB_ ) )
071                ICOFFC = MOD( JC - 1 , DESCC( NB_ ) )
072                IAROW = INDXG2P( IA , DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) ,
073       $        NPROW )
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                    LWMIN = MAX(( DESCA( NB_ ) * ( DESCA( NB_ ) - 1 ) ) / 2 ,
083       $( MPC0 + NQC0 ) * DESCA( NB_ ) ) +
083                       
084       $            DESCA( NB_ ) * DESCA( NB_ )
085                ELSE
085                       
086                    NPA0 = NUMROC( N + IROFFA , DESCA( MB_ ) , MYROW , IAROW ,
087       $            NPROW )
088                    LCM = ILCM( NPROW , NPCOL )
089                    LCMQ = LCM / NPCOL
090                    LWMIN = MAX(( DESCA( NB_ ) * ( DESCA( NB_ ) - 1 ) )
091       $            / 2 ,( NQC0 + MAX( NPA0 + NUMROC( NUMROC(
092       $            N + ICOFFC , DESCA( NB_ ) , 0 , 0 , NPCOL ) ,
093       $            DESCA( NB_ ) , 0 , 0 , LCMQ ) , MPC0 ) ) *
094       $            DESCA( NB_ ) ) + DESCA( NB_ ) * DESCA( NB_ )
095                END IF
096  
097                WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )
098                LQUERY =( LWORK.EQ. - 1 )
099                IF( .NOT.LEFT .AND. .NOT.LSAME( SIDE , 'R' ) ) THEN
099                       
100                    INFO = - 1
101                ELSE IF( .NOT.NOTRAN .AND. .NOT.LSAME( TRANS , 'C' ) ) THEN
101                       
102                    INFO = - 2
103                ELSE IF( K.LT.0 .OR. K.GT.NQ ) THEN
103                       
104                    INFO = - 5
105                ELSE IF( .NOT.LEFT .AND. DESCA( MB_ ).NE.DESCC( NB_ ) ) THEN
105                       
106                    INFO = - (900 + NB_)
107                ELSE IF( LEFT .AND. IROFFA.NE.IROFFC ) THEN
107                       
108                    INFO = - 12
109                ELSE IF( LEFT .AND. IAROW.NE.ICROW ) THEN
109                       
110                    INFO = - 12
111                ELSE IF( .NOT.LEFT .AND. IROFFA.NE.ICOFFC ) THEN
111                       
112                    INFO = - 13
113                ELSE IF( LEFT .AND. DESCA( MB_ ).NE.DESCC( MB_ ) ) THEN
113                       
114                    INFO = - (1400 + MB_)
115                ELSE IF( ICTXT.NE.DESCC( CTXT_ ) ) THEN
115                       
116                    INFO = - (1400 + CTXT_)
117                ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
117                       
118                    INFO = - 16
119                END IF
120            END IF
121  
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( 'C' )
132            END IF
133            IDUM2( 2 ) = 2
134            IDUM1( 3 ) = K
135            IDUM2( 3 ) = 5
136            IF( LWORK.EQ. - 1 ) THEN
136                   
137                IDUM1( 4 ) = - 1
138            ELSE
138                   
139                IDUM1( 4 ) = 1
140            END IF
141            IDUM2( 4 ) = 16
142            IF( LEFT ) THEN
142                   
143                CALL PCHK2MAT( M , 3 , K , 5 , IA , JA , DESCA , 9 , M , 3 , N , 4 , IC ,
144       $        JC , DESCC , 14 , 4 , IDUM1 , IDUM2 , INFO )
145            ELSE
145                   
146                CALL PCHK2MAT( N , 4 , K , 5 , IA , JA , DESCA , 9 , M , 3 , N , 4 , IC ,
147       $        JC , DESCC , 14 , 4 , IDUM1 , IDUM2 , INFO )
148            END IF
149        END IF
150  
151        IF( INFO.NE.0 ) THEN
151               
152            CALL PXERBLA( ICTXT , 'PZUNMQL' , - INFO )
153            RETURN
154        ELSE IF( LQUERY ) THEN
154               
155            RETURN
156        END IF
157  
158  *     Quick return if possible
159  
160        IF( M.EQ.0 .OR. N.EQ.0 .OR. K.EQ.0 )
160               
161       $    RETURN
162  
163            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
164            CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
165  
166            IF(( LEFT .AND. NOTRAN ) .OR.
167       $( .NOT.LEFT .AND. .NOT.NOTRAN ) ) THEN
167               
168            J1 = MIN( ICEIL( JA , DESCA( NB_ ) )*DESCA( NB_ ) , JA + K - 1 ) + 1
169            J2 = JA + K - 1
170            J3 = DESCA( NB_ )
171        ELSE
171               
172            J1 = MAX(((JA + K - 2) / DESCA( NB_ ) ) * DESCA( NB_ ) + 1 , JA )
173            J2 = MIN( ICEIL( JA , DESCA( NB_ ) )*DESCA( NB_ ) , JA + K - 1 ) + 1
174            J3 = - DESCA( NB_ )
175        END IF
176  
177        IF( LEFT ) THEN
177               
178            NI = N
179            IF( NOTRAN ) THEN
179                   
180                CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , 'I - ring' )
181            ELSE
181                   
182                CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , 'D - ring' )
183            END IF
184            CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , ' ' )
185        ELSE
185               
186            MI = M
187        END IF
188  
189  *     Use unblocked code for the first block if necessary
190  
191        IF(( LEFT .AND. NOTRAN ) .OR.
192       $( .NOT.LEFT .AND. .NOT.NOTRAN ) ) THEN
193        JB = J1 - JA
194        IF( LEFT ) THEN
194               
195            MI = M - K + JB
196        ELSE
196               
197            NI = N - K + JB
198        END IF
199        CALL PZUNM2L ( SIDE , TRANS , MI , NI , JB , A , IA , JA , DESCA , TAU ,
200       $C , IC , JC , DESCC , WORK , LWORK , IINFO )
201        END IF
202  
203        IPW = DESCA( NB_ ) * DESCA( NB_ ) + 1
204        DO 10 J = J1 , J2 , J3
204               
205            JB = MIN( DESCA( NB_ ) , K - J + JA )
206  
207  *         Form the triangular factor of the block reflector
208  *         H = H(j + jb - 1) . . . H(j + 1) H(j)
209  
210            CALL PZLARFT ( 'Backward' , 'Columnwise' , NQ - K + J + JB - JA , JB ,
211       $    A , IA , J , DESCA , TAU , WORK , WORK( IPW ) )
212            IF( LEFT ) THEN
213  
214  *             H or H' is applied to C(ic : ic + m - k + j + jb - ja - 1 , jc : jc + n - 1)
215  
215                   
216                MI = M - K + J + JB - JA
217            ELSE
218  
219  *             H or H' is applied to C(ic : ic + m - 1 , jc : jc + n - k + j + jb - ja - 1)
220  
220                   
221                NI = N - K + J + JB - JA
222            END IF
223  
224  *         Apply H or H'
225  
226            CALL PZLARFB ( SIDE , TRANS , 'Backward' , 'Columnwise' , MI , NI ,
227       $    JB , A , IA , J , DESCA , WORK , C , IC , JC , DESCC ,
228       $    WORK( IPW ) )
229     10 CONTINUE
230  
231        IF(( LEFT .AND. .NOT.NOTRAN ) .OR.
232       $( .NOT.LEFT .AND. NOTRAN ) ) THEN
233        JB = J2 - JA
234        IF( LEFT ) THEN
234               
235            MI = M - K + JB
236        ELSE
236               
237            NI = N - K + JB
238        END IF
239        CALL PZUNM2L ( SIDE , TRANS , MI , NI , JB , A , IA , JA , DESCA , TAU ,
240       $C , IC , JC , DESCC , WORK , LWORK , IINFO )
241        END IF
242  
243        CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
244        CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
245  
246        WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )
247  
248        RETURN
249  
250  *     End of PZUNMQL
251  
252        END2834

Variables in Routine PZUNMQL()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	4	4
INTEGER	53	240
LOGICAL	4	4
REAL	1	4
TOTAL	62	252

List of Variables

CHARACTER

COLBTOP ROWBTOP SIDE TRANS

INTEGER

BLOCK_CYCLIC_2D CSRC_ CTXT_ DLEN_ DTYPE_
IA IAROW IC ICCOL ICEIL
ICOFFC ICROW ICTXT IDUM1( 4 ) IDUM2( 4 )
IINFO ILCM INDXG2P INFO IPW
IROFFA IROFFC J J1 J2
J3 JA JB JC K
LCM LCMQ LLD_ LWMIN LWORK
M M_ MB_ MI MPC0
MYCOL MYROW N N_ NB_
NI NPA0 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
-
- -
IAROW <--- INDXG2P, MB_, MYROW, NPROW, RSRC_, IA

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

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

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

ICTXT <--- CTXT_ICTXT = DESCA( CTXT_ )

IDUM1 <--- KIDUM1( 3 ) = K, NIDUM1( 2 ) = ICHAR( 'N' )

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

IPW <--- NB_IPW = DESCA( NB_ ) * DESCA( NB_ ) + 1

IROFFA <--- MB_IROFFA = MOD( IA-1, DESCA( MB_ ) ), IAIROFFA = MOD( IA-1, DESCA( MB_ ) )

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

J <--- J1DO 10 J = J1, J2, J3, J2DO 10 J = J1, J2, J3, J3DO 10 J = J1, J2, J3

J1 <--- ICEIL, JA{2}, K{2}, NB_{2}

J2 <--- ICEIL, JAJ2 = JA+K-1{2}, KJ2 = JA+K-1{2}, NB_

J3 <--- NB_J3 = DESCA( NB_ ){2J3 = -DESCA( NB_ )}

JB <--- JJB = MIN( DESCA( NB_ ), K-J+JA ), J1JB = J1 - JA, J2JB = J2 - JA, JAJB = J1 - JA{2JB = MIN( DESCA( NB_ ), K-J+JA ), 3JB = J2 - JA}, KJB = MIN( DESCA( NB_ ), K-J+JA ), NB_JB = MIN( DESCA( NB_ ), K-J+JA )

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

LCMQ <--- LCMLCMQ = LCM / NPCOL, NPCOLLCMQ = LCM / NPCOL

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

LWMIN <--- ICOFFC, LCMQ, MPC0{2}, N, NB_{2}, NPA0, NPCOL, NQC0{2}, NUMROC

MI <--- JMI = M - K + J + JB - JA, JAMI = M - K + J + JB - JA, JBMI = M - K + JB{2MI = M - K + J + JB - JA, 3MI = M - K + JB}, KMI = M - K + JB{2MI = M - K + J + JB - JA, 3MI = M - K + JB}, MMI = M{2MI = M - K + JB, 3MI = M - K + J + JB - JA, 4MI = M - K + JB}

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

NI <--- JNI = N - K + J + JB - JA, JANI = N - K + J + JB - JA, JBNI = N - K + JB{2NI = N - K + J + JB - JA, 3NI = N - K + JB}, KNI = N - K + JB{2NI = N - K + J + JB - JA, 3NI = N - K + JB}, NNI = N{2NI = N - K + JB, 3NI = N - K + J + JB - JA, 4NI = N - K + JB}

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

NPA0 <--- IROFFA, MB_, MYROW, N, NPROW, NUMROC, IAROW

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

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

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

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

Assigned variables
		BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ , IAROW , ICCOL , ICOFFC , ICROW , ICTXT , IDUM1 , IDUM2 , INFO , IPW , IROFFA , IROFFC , J , J1 , J2 , J3 , JB , LCM , LCMQ , LEFT , LLD_ , LQUERY , LWMIN , M_ , MB_ , MI , MPC0 , N_ , NB_ , NI , NOTRAN , NPA0 , NQ , NQC0 , RSRC_ , WORK

Active variables
		A , BLOCK_CYCLIC_2D , C , COLBTOP , CSRC_ , CTXT_ , DESCA , DESCC , DLEN_ , DTYPE_ , IA , IAROW , IC , ICCOL , ICEIL , ICOFFC , ICROW , ICTXT , IDUM1 , IDUM2 , IINFO , ILCM , INDXG2P , INFO , IPW , IROFFA , IROFFC , J , J1 , J2 , J3 , JA , JB , JC , K , LCM , LCMQ , LEFT , LLD_ , LQUERY , LSAME , LWMIN , LWORK , M , M_ , MB_ , MI , MPC0 , MYCOL , MYROW , N , N_ , NB_ , NI , NOTRAN , NPA0 , NPCOL , NPROW , NQ , NQC0 , NUMROC , ROWBTOP , RSRC_ , SIDE , TAU , TRANS , WORK

Accessed arrays [ array name : associated index ]
	C	: ic:ic+m-1,jc:jc+n-k+j+jb-ja-1 , ic:ic+m-k+j+jb-ja-1,jc:jc+n-1
	DESCA	: CTXT_ , MB_ , MB_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , RSRC_
	DESCC	: CSRC_ , CTXT_ , MB_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_ , RSRC_
	ICEIL	: JA, DESCA( NB_ ) , JA, DESCA( NB_ )
	IDUM1	: 1 , 1 , 2 , 2 , 3 , 4 , 4 , 4
	IDUM2	: 1 , 2 , 3 , 4 , 4
	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 , IPW , IPW

Conditional statements [ statement : associated predicate ]
	do	: `(` 10 J = J1 , J2 , J3 `)`
	for	: `(` the first block if necessary `)`
	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 `)` , `(` (.NOT.LEFT .AND. DESCA( MB_ ).NE.DESCC( NB_ ) ) `)` , `(` LEFT .AND. IROFFA.NE.IROFFC `)` , `(` LEFT .AND. IAROW.NE.ICROW `)` , `(` .NOT.LEFT .AND. IROFFA.NE.ICOFFC `)` , `(` (LEFT .AND. DESCA( MB_ ).NE.DESCC( MB_ ) ) `)` , `(` (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. NOTRAN ) .OR. `)` , `(` LEFT `)` , `(` NOTRAN `)` , `(` necessary `)` , `(` (( LEFT .AND. NOTRAN ) .OR. `)` , `(` LEFT `)` , `(` LEFT `)` , `(` (( LEFT .AND. .NOT.NOTRAN ) .OR. `)` , `(` LEFT `)`