Routine PCUNM2R() Documented By Universal Report

Routine: PCUNM2R()

File: SRC\pcunm2r.f

# lines:	449
# code:	449
# comment:	0
# blank:	0
# Variables:	63
# Callers:	1
# Callings:	2
# Words:	283
# Keywords:	185

..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PCUNM2R overwrites the general complex M-by-N distributed matrix
  sub( C ) = C(IC:IC+M-1,JC:JC+N-1) with
                      SIDE = 'L'            SIDE = 'R'
  TRANS = 'N':      Q * sub( C )          sub( C ) * Q
  TRANS = 'C':      Q**H * sub( C )       sub( C ) * Q**H
  where Q is a complex unitary distributed matrix defined as the
  product of k elementary reflectors
        Q = H(1) H(2) . . . H(k)
  as returned by PCGEQRF. Q is of order M if SIDE = 'L' and of order N
  if SIDE = 'R'.
  Notes
  =====
  Each global data object is described by an associated description
  vector.  This vector stores the information required to establish
  the mapping between an object element and its corresponding process
  and memory location.
  Let A be a generic term for any 2D block cyclicly distributed array.
  Such a global array has an associated description vector DESCA.
  In the following comments, the character _ should be read as
  "of the global array".
  NOTATION        STORED IN      EXPLANATION
  --------------- -------------- --------------------------------------
  DTYPE_A(global) DESCA( DTYPE_ )The descriptor type.  In this case,
                                 DTYPE_A = 1.
  CTXT_A (global) DESCA( CTXT_ ) The BLACS context handle, indicating
                                 the BLACS process grid A is distribu-
                                 ted over. The context itself is glo-
                                 bal, but the handle (the integer
                                 value) may vary.
  M_A    (global) DESCA( M_ )    The number of rows in the global
                                 array A.
  N_A    (global) DESCA( N_ )    The number of columns in the global
                                 array A.
  MB_A   (global) DESCA( MB_ )   The blocking factor used to distribute
                                 the rows of the array.
  NB_A   (global) DESCA( NB_ )   The blocking factor used to distribute
                                 the columns of the array.
  RSRC_A (global) DESCA( RSRC_ ) The process row over which the first
                                 row of the array A is distributed.
  CSRC_A (global) DESCA( CSRC_ ) The process column over which the
                                 first column of the array A is
                                 distributed.
  LLD_A  (local)  DESCA( LLD_ )  The leading dimension of the local
                                 array.  LLD_A >= MAX(1,LOCr(M_A)).
  Let K be the number of rows or columns of a distributed matrix,
  and assume that its process grid has dimension p x q.
  LOCr( K ) denotes the number of elements of K that a process
  would receive if K were distributed over the p processes of its
  process column.
  Similarly, LOCc( K ) denotes the number of elements of K that a
  process would receive if K were distributed over the q processes of
  its process row.
  The values of LOCr() and LOCc() may be determined via a call to the
  ScaLAPACK tool function, NUMROC:
          LOCr( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
          LOCc( N ) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).
  An upper bound for these quantities may be computed by:
          LOCr( M ) <= ceil( ceil(M/MB_A)/NPROW )*MB_A
          LOCc( N ) <= ceil( ceil(N/NB_A)/NPCOL )*NB_A
  Arguments
  =========
  SIDE    (global input) CHARACTER
          = 'L': apply Q or Q**H from the Left;
          = 'R': apply Q or Q**H from the Right.
  TRANS   (global input) CHARACTER
          = 'N':  No transpose, apply Q;
          = 'C':  Conjugate transpose, apply Q**H.
  M       (global input) INTEGER
          The number of rows to be operated on i.e the number of rows
          of the distributed submatrix sub( C ). M >= 0.
  N       (global input) INTEGER
          The number of columns to be operated on i.e the number of
          columns of the distributed submatrix sub( C ). N >= 0.
  K       (global input) INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q.  If SIDE = 'L', M >= K >= 0, if SIDE = 'R',
          N >= K >= 0.
  A       (local input) COMPLEX pointer into the local memory
          to an array of dimension (LLD_A,LOCc(JA+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
          PCGEQRF 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, array, dimension LOCc(JA+K-1).
          This array contains the scalar factors TAU(j) of the
          elementary reflectors H(j) as returned by PCGEQRF.
          TAU is tied to the distributed matrix A.
  C       (local input/local output) COMPLEX pointer into the
          local memory to an array of dimension (LLD_C,LOCc(JC+N-1)).
          On entry, the local pieces of the distributed matrix sub(C).
          On exit, sub( C ) is overwritten by Q*sub( C ) or Q'*sub( C )
          or sub( C )*Q' or sub( C )*Q.
  IC      (global input) INTEGER
          The row index in the global array C indicating the first
          row of sub( C ).
  JC      (global input) INTEGER
          The column index in the global array C indicating the
          first column of sub( C ).
  DESCC   (global and local input) INTEGER array of dimension DLEN_.
          The array descriptor for the distributed matrix C.
  WORK    (local workspace/local output) COMPLEX array,
                                                     dimension (LWORK)
          On exit, WORK(1) returns the minimal and optimal LWORK.
  LWORK   (local or global input) INTEGER
          The dimension of the array WORK.
          LWORK is local input and must be at least
          If SIDE = 'L', LWORK >= MpC0 + MAX( 1, NqC0 );
          if SIDE = 'R', LWORK >= NqC0 + MAX( MAX( 1, MpC0 ), NUMROC(
                   NUMROC( N+ICOFFC,NB_A,0,0,NPCOL ),NB_A,0,0,LCMQ ) );
          where LCMQ = LCM / NPCOL with LCM = ICLM( NPROW, NPCOL ),
          IROFFC = MOD( IC-1, MB_C ), ICOFFC = MOD( JC-1, NB_C ),
          ICROW = INDXG2P( IC, MB_C, MYROW, RSRC_C, NPROW ),
          ICCOL = INDXG2P( JC, NB_C, MYCOL, CSRC_C, NPCOL ),
          MpC0 = NUMROC( M+IROFFC, MB_C, MYROW, ICROW, NPROW ),
          NqC0 = NUMROC( N+ICOFFC, NB_C, MYCOL, ICCOL, NPCOL ),
          ILCM, INDXG2P and NUMROC are ScaLAPACK tool functions;
          MYROW, MYCOL, NPROW and NPCOL can be determined by calling
          the subroutine BLACS_GRIDINFO.
          If LWORK = -1, then LWORK is global input and a workspace
          query is assumed; the routine only calculates the minimum
          and optimal size for all work arrays. Each of these
          values is returned in the first entry of the corresponding
          work array, and no error message is issued by PXERBLA.
  INFO    (local output) INTEGER
          = 0:  successful exit
          < 0:  If the i-th argument is an array and the j-entry had
                an illegal value, then INFO = -(i*100+j), if the i-th
                argument is a scalar and had an illegal value, then
                INFO = -i.
  Alignment requirements
  ======================
  The distributed submatrices A(IA:*, JA:*) and C(IC:IC+M-1,JC:JC+N-1)
  must verify some alignment properties, namely the following
  expressions should be true:
  If SIDE = 'L',
    ( 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 PCUNM2R( SIDE , TRANS , M , N , K , A , IA , JA , DESCA , TAU ,
002       $C , IC , JC , DESCC , WORK , LWORK , INFO )
003  
004  *     -- ScaLAPACK routine(version 1.7) --
005  *     University of Tennessee , Knoxville , Oak Ridge National Laboratory ,
006  *     and University of California , Berkeley.
007  *     May 25 , 2001
008  
009  *     .. Scalar Arguments ..
010        CHARACTER SIDE , TRANS
011        INTEGER IA , IC , INFO , JA , JC , K , LWORK , M , N
012        INTEGER BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ ,
013       $LLD_ , MB_ , M_ , NB_ , N_ , RSRC_
014        PARAMETER( BLOCK_CYCLIC_2D = 1 , DLEN_ = 9 , DTYPE_ = 1 ,
015       $CTXT_ = 2 , M_ = 3 , N_ = 4 , MB_ = 5 , NB_ = 6 ,
016       $RSRC_ = 7 , CSRC_ = 8 , LLD_ = 9 )
017        COMPLEX ONE
018        PARAMETER( ONE =( 1.0E + 0 , 0.0E + 0 ) )
019  *     ..
020  *     .. Local Scalars ..
021        LOGICAL LEFT , LQUERY , NOTRAN
022        CHARACTER COLBTOP , ROWBTOP
023        INTEGER IACOL , IAROW , ICCOL , ICOFFC , ICROW , ICTXT , ICC ,
024       $II , IROFFA , IROFFC , J , J1 , J2 , J3 , JCC , JJ ,
025       $LCM , LCMQ , LWMIN , MI , MP , MPC0 , MYCOL , MYROW ,
026       $NI , NPCOL , NPROW , NQ , NQC0
027        COMPLEX AJJ
028  *     ..
029  *     .. External Subroutines ..
030        EXTERNAL BLACS_ABORT , BLACS_GRIDINFO , CGEBR2D ,
031       $CGEBS2D , CGERV2D , CGESD2D , CHK1MAT ,
032       $CSCAL , INFOG2L , PCELSET , PCELSET2 ,
033       $PCLARF , PCLARFC , PB_TOPGET , PB_TOPSET , PXERBLA
034  *     ..
035  *     .. External Functions ..
036        LOGICAL LSAME
037        INTEGER ILCM , INDXG2P , NUMROC
038        EXTERNAL ILCM , INDXG2P , LSAME , NUMROC
039  *     ..
040  *     .. Intrinsic Functions ..
041        INTRINSIC CMPLX , CONJG , MAX , MOD , REAL
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 = - (900 + CTXT_)
055        ELSE
055               
056            LEFT = LSAME( SIDE , 'L' )
057            NOTRAN = LSAME( TRANS , 'N' )
058  
059  *         NQ is the order of Q
060  
061            IF( LEFT ) THEN
061                   
062                NQ = M
063                CALL CHK1MAT( M , 3 , K , 5 , IA , JA , DESCA , 9 , INFO )
064            ELSE
064                   
065                NQ = N
066                CALL CHK1MAT( N , 4 , K , 5 , IA , JA , DESCA , 9 , INFO )
067            END IF
068            CALL CHK1MAT( M , 3 , N , 4 , IC , JC , DESCC , 14 , INFO )
069            IF( INFO.EQ.0 ) THEN
069                   
070                IROFFA = MOD( IA - 1 , DESCA( MB_ ) )
071                IROFFC = MOD( IC - 1 , DESCC( MB_ ) )
072                ICOFFC = MOD( JC - 1 , DESCC( NB_ ) )
073                IAROW = INDXG2P( IA , DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) ,
074       $        NPROW )
075                ICROW = INDXG2P( IC , DESCC( MB_ ) , MYROW , DESCC( RSRC_ ) ,
076       $        NPROW )
077                ICCOL = INDXG2P( JC , DESCC( NB_ ) , MYCOL , DESCC( CSRC_ ) ,
078       $        NPCOL )
079                MPC0 = NUMROC( M + IROFFC , DESCC( MB_ ) , MYROW , ICROW , NPROW )
080                NQC0 = NUMROC( N + ICOFFC , DESCC( NB_ ) , MYCOL , ICCOL , NPCOL )
081  
082                IF( LEFT ) THEN
082                       
083                    LWMIN = MPC0 + MAX( 1 , NQC0 )
084                ELSE
084                       
085                    LCM = ILCM( NPROW , NPCOL )
086                    LCMQ = LCM / NPCOL
087                    LWMIN = NQC0 + MAX( MAX( 1 , MPC0 ) , NUMROC( NUMROC(
088       $            N + ICOFFC , DESCA( NB_ ) , 0 , 0 , NPCOL ) ,
089       $            DESCA( NB_ ) , 0 , 0 , LCMQ ) )
090                END IF
091  
092                WORK( 1 ) = CMPLX( REAL( LWMIN ) )
093                LQUERY =( LWORK.EQ. - 1 )
094                IF( .NOT.LEFT .AND. .NOT.LSAME( SIDE , 'R' ) ) THEN
094                       
095                    INFO = - 1
096                ELSE IF( .NOT.NOTRAN .AND. .NOT.LSAME( TRANS , 'C' ) ) THEN
096                       
097                    INFO = - 2
098                ELSE IF( K.LT.0 .OR. K.GT.NQ ) THEN
098                       
099                    INFO = - 5
100                ELSE IF( .NOT.LEFT .AND. DESCA( MB_ ).NE.DESCC( NB_ ) ) THEN
100                       
101                    INFO = - (900 + NB_)
102                ELSE IF( LEFT .AND. IROFFA.NE.IROFFC ) THEN
102                       
103                    INFO = - 12
104                ELSE IF( LEFT .AND. IAROW.NE.ICROW ) THEN
104                       
105                    INFO = - 12
106                ELSE IF( .NOT.LEFT .AND. IROFFA.NE.ICOFFC ) THEN
106                       
107                    INFO = - 13
108                ELSE IF( LEFT .AND. DESCA( MB_ ).NE.DESCC( MB_ ) ) THEN
108                       
109                    INFO = - (1400 + MB_)
110                ELSE IF( ICTXT.NE.DESCC( CTXT_ ) ) THEN
110                       
111                    INFO = - (1400 + CTXT_)
112                ELSE IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
112                       
113                    INFO = - 16
114                END IF
115            END IF
116        END IF
117  
118        IF( INFO.NE.0 ) THEN
118               
119            CALL PXERBLA( ICTXT , 'PCUNM2R' , - INFO )
120            CALL BLACS_ABORT( ICTXT , 1 )
121            RETURN
122        ELSE IF( LQUERY ) THEN
122               
123            RETURN
124        END IF
125  
126  *     Quick return if possible
127  
128        IF( M.EQ.0 .OR. N.EQ.0 .OR. K.EQ.0 )
128               
129       $    RETURN
130  
131            IF( DESCA( M_ ).EQ.1 ) THEN
131                   
132                CALL INFOG2L( IA , JA , DESCA , NPROW , NPCOL , MYROW , MYCOL , II ,
133       $        JJ , IAROW , IACOL )
134                CALL INFOG2L( IC , JC , DESCC , NPROW , NPCOL , MYROW , MYCOL , ICC ,
135       $        JCC , ICROW , ICCOL )
136                IF( LEFT ) THEN
136                       
137                    IF( MYROW.EQ.IAROW ) THEN
137                           
138                        NQ = NUMROC( JC + N - 1 , DESCC( NB_ ) , MYCOL , DESCC( CSRC_ ) ,
139       $                NPCOL )
140                        IF( MYCOL.EQ.IACOL ) THEN
140                               
141                            IF( NOTRAN ) THEN
141                                   
142                                AJJ = ONE - TAU( JJ )
143                            ELSE
143                                   
144                                AJJ = ONE - CONJG( TAU( JJ ) )
145                            END IF
146                            CALL CGEBS2D( ICTXT , 'Rowwise' , ' ' , 1 , 1 , AJJ , 1 )
147                            CALL CSCAL( NQ - JCC + 1 , AJJ ,
148       $                    C( ICC + (JCC - 1)*DESCC( LLD_ ) ) ,
149       $                    DESCC( LLD_ ) )
150                        ELSE
150                               
151                            CALL CGEBR2D( ICTXT , 'Rowwise' , ' ' , 1 , 1 , AJJ , 1 ,
152       $                    IAROW , IACOL )
153                            CALL CSCAL( NQ - JCC + 1 , AJJ ,
154       $                    C( ICC + (JCC - 1)*DESCC( LLD_ ) ) ,
155       $                    DESCC( LLD_ ) )
156                        END IF
157                    END IF
158                ELSE
158                       
159                    IF( MYCOL.EQ.IACOL ) THEN
159                           
160                        IF( NOTRAN ) THEN
160                               
161                            AJJ = ONE - TAU( JJ )
162                        ELSE
162                               
163                            AJJ = ONE - CONJG( TAU( JJ ) )
164                        END IF
165                    END IF
166  
167                    IF( IACOL.NE.ICCOL ) THEN
167                           
168                        IF( MYCOL.EQ.IACOL )
168                               
169       $                    CALL CGESD2D( ICTXT , 1 , 1 , AJJ , 1 , MYROW , ICCOL )
170                            IF( MYCOL.EQ.ICCOL )
170                                   
171       $                        CALL CGERV2D( ICTXT , 1 , 1 , AJJ , 1 , MYROW , IACOL )
172                            END IF
173  
174                            IF( MYCOL.EQ.ICCOL ) THEN
174                                   
175                                MP = NUMROC( IC + M - 1 , DESCC( MB_ ) , MYROW , DESCC( RSRC_ ) ,
176       $                        NPROW )
177                                CALL CSCAL( MP - ICC + 1 , AJJ , C( ICC + (JCC - 1)*
178       $                        DESCC( LLD_ ) ) , 1 )
179                            END IF
180  
181                        END IF
182  
183                    ELSE
184  
184                           
185                        CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
186                        CALL PB_TOPGET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
187  
188                        IF( LEFT .AND. .NOT.NOTRAN .OR. .NOT.LEFT .AND. NOTRAN ) THEN
188                               
189                            J1 = JA
190                            J2 = JA + K - 1
191                            J3 = 1
192                        ELSE
192                               
193                            J1 = JA + K - 1
194                            J2 = JA
195                            J3 = - 1
196                        END IF
197  
198                        IF( LEFT ) THEN
198                               
199                            NI = N
200                            JCC = JC
201                            IF( NOTRAN ) THEN
201                                   
202                                CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , 'D - ring' )
203                            ELSE
203                                   
204                                CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , 'I - ring' )
205                            END IF
206                            CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , ' ' )
207                        ELSE
207                               
208                            MI = M
209                            ICC = IC
210                        END IF
211  
212                        DO 10 J = J1 , J2 , J3
212                               
213                            IF( LEFT ) THEN
214  
215  *                             H(j) or H(j)' is applied to C(ic + j - ja : ic + m - 1 , jc : jc + n - 1)
216  
216                                   
217                                MI = M - J + JA
218                                ICC = IC + J - JA
219                            ELSE
220  
221  *                             H(j) or H(j)' is applied to C(ic : ic + m - 1 , jc + j - ja : jc + n - 1)
222  
222                                   
223                                NI = N - J + JA
224                                JCC = JC + J - JA
225                            END IF
226  
227  *                         Apply H(j) or H(j)'
228  
229                            CALL PCELSET2( AJJ , A , IA + J - JA , J , DESCA , ONE )
230                            IF( NOTRAN ) THEN
230                                   
231                                CALL PCLARF ( SIDE , MI , NI , A , IA + J - JA , J , DESCA , 1 , TAU ,
232       $                        C , ICC , JCC , DESCC , WORK )
233                            ELSE
233                                   
234                                CALL PCLARFC ( SIDE , MI , NI , A , IA + J - JA , J , DESCA , 1 , TAU ,
235       $                        C , ICC , JCC , DESCC , WORK )
236                            END IF
237                            CALL PCELSET( A , IA + J - JA , J , DESCA , AJJ )
238  
239     10                 CONTINUE
240  
240                           
241                        CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Rowwise' , ROWBTOP )
242                        CALL PB_TOPSET( ICTXT , 'Broadcast' , 'Columnwise' , COLBTOP )
243  
244                    END IF
245  
246                    WORK( 1 ) = CMPLX( REAL( LWMIN ) )
247  
248                    RETURN
249  
250  *                 End of PCUNM2R
251  
252                END2335

Variables in Routine PCUNM2R()

Summary Report
Data Type	Quantity	Size(byte)
CHARACTER	4	4
COMPLEX	2	8
INTEGER	52	208
LOGICAL	4	4
REAL	1	4
TOTAL	63	228

List of Variables

CHARACTER

COLBTOP ROWBTOP SIDE TRANS

COMPLEX

AJJ ONE

INTEGER

BLOCK_CYCLIC_2D CSRC_ CTXT_ DLEN_ DTYPE_
IA IACOL IAROW IC ICC
ICCOL ICOFFC ICROW ICTXT II
ILCM INDXG2P INFO IROFFA IROFFC
J J1 J2 J3 JA
JC JCC JJ K LCM
LCMQ LLD_ LWMIN LWORK M
M_ MB_ MI MP MPC0
MYCOL MYROW N N_ NB_
NI NPCOL NPROW NQ NQC0
NUMROC RSRC_

LOGICAL

LEFT LQUERY LSAME NOTRAN

REAL

WORK

Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence
-
- -
AJJ <--- JJAJJ = ONE - TAU( JJ ){2AJJ = ONE - CONJG( TAU( JJ ) ), 3AJJ = ONE - TAU( JJ ), 4AJJ = ONE - CONJG( TAU( JJ ) )}, ONEAJJ = ONE - TAU( JJ ){2AJJ = ONE - CONJG( TAU( JJ ) ), 3AJJ = ONE - TAU( JJ ), 4AJJ = ONE - CONJG( TAU( JJ ) )}

IAROW <--- INDXG2P, MB_, MYROW, NPROW, RSRC_, IA

ICC <--- ICICC = IC{2ICC = IC + J - JA}, JICC = IC + J - JA, JAICC = IC + J - JA

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

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

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

ICTXT <--- CTXT_ICTXT = DESCA( CTXT_ )

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

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

IROFFC <--- ICIROFFC = MOD( IC-1, DESCC( MB_ ) ), MB_IROFFC = 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 <--- JAJ1 = JA{2J1 = JA+K-1}, KJ1 = JA+K-1

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

JCC <--- JJCC = JC + J - JA, JAJCC = JC + J - JA, JCJCC = JC{2JCC = JC + 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, MPC0LWMIN = MPC0 + MAX( 1, NQC0 ){2}, N, NB_, NPCOL, NQC0LWMIN = MPC0 + MAX( 1, NQC0 ){2}, NUMROC

MI <--- JMI = M - J + JA, JAMI = M - J + JA, MMI = M{2MI = M - J + JA}

MP <--- IC, M, MB_, MYROW, NPROW, NUMROC, RSRC_

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

NI <--- JNI = N - J + JA, JANI = N - J + JA, NNI = N{2NI = N - J + JA}

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

NQ <--- JC, CSRC_, MNQ = M, MYCOL, N{2NQ = N}, NB_, NPCOL, NUMROC

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

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

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

Assigned variables
		AJJ , BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ , IAROW , ICC , ICCOL , ICOFFC , ICROW , ICTXT , INFO , IROFFA , IROFFC , J , J1 , J2 , J3 , JCC , LCM , LCMQ , LEFT , LLD_ , LQUERY , LWMIN , M_ , MB_ , MI , MP , MPC0 , N_ , NB_ , NI , NOTRAN , NQ , NQC0 , ONE , RSRC_ , WORK

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

Accessed arrays [ array name : associated index ]
	C	: ic:ic+m-1,jc+j-ja:jc+n-1 , ic+j-ja:ic+m-1,jc:jc+n-1 , ICC+(JCC-1)DESCC( LLD_ ) , ICC+(JCC-1)DESCC( LLD_ )
	DESCA	: CTXT_ , M_ , MB_ , MB_ , MB_ , MB_ , NB_ , NB_ , RSRC_
	DESCC	: CSRC_ , CSRC_ , CTXT_ , LLD_ , LLD_ , LLD_ , LLD_ , LLD_ , MB_ , MB_ , MB_ , MB_ , MB_ , NB_ , NB_ , NB_ , NB_ , NB_ , RSRC_ , RSRC_
	ILCM	: NPROW, NPCOL
	LSAME	: SIDE, 'L' , SIDE, 'R' , TRANS, 'C' , TRANS, 'N'
	NUMROC	: M+IROFFC, DESCC( MB_ ), MYROW, ICROW, NPROW , N+ICOFFC, DESCC( NB_ ), MYCOL, ICCOL, NPCOL
	TAU	: JJ , JJ , JJ , JJ
	WORK	: 1 , 1

Conditional statements [ statement : associated predicate ]
	do	: `(` 10 J = J1 , J2 , J3 `)`
	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 `)` , `(` INFO.NE.0 `)` , `(` LQUERY `)` , `(` possible `)` , `(` M.EQ.0 .OR. N.EQ.0 .OR. K.EQ.0 `)` , `(` (DESCA( M_ ).EQ.1 ) `)` , `(` LEFT `)` , `(` MYROW.EQ.IAROW `)` , `(` MYCOL.EQ.IACOL `)` , `(` NOTRAN `)` , `(` MYCOL.EQ.IACOL `)` , `(` NOTRAN `)` , `(` IACOL.NE.ICCOL `)` , `(` MYCOL.EQ.IACOL `)` , `(` MYCOL.EQ.ICCOL `)` , `(` MYCOL.EQ.ICCOL `)` , `(` LEFT .AND. .NOT.NOTRAN .OR. .NOT.LEFT .AND. NOTRAN `)` , `(` LEFT `)` , `(` NOTRAN `)` , `(` LEFT `)` , `(` NOTRAN `)`