Routine PZGEQPF() Documented By Universal Report

Routine: PZGEQPF()

# lines:	566
# code:	566
# comment:	0
# blank:	0
# Variables:	72
# Callers:	0
# Callings:	2
# Words:	394
# Keywords:	229

..
     .. Array Arguments ..
     ..
  Purpose
  =======
  PZGEQPF computes a QR factorization with column pivoting of a
  M-by-N distributed matrix sub( A ) = A(IA:IA+M-1,JA:JA+N-1):
                         sub( A ) * P = Q * 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
  =========
  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/local output) COMPLEX*16 pointer into the
          local memory to an array of dimension (LLD_A, LOCc(JA+N-1)).
          On entry, the local pieces of the M-by-N distributed matrix
          sub( A ) which is to be factored. On exit, the elements on
          and above the diagonal of sub( A ) contain the min(M,N) by N
          upper trapezoidal matrix R (R is upper triangular if M >= N);
          the elements below the diagonal, with the array TAU, repre-
          sent the unitary matrix Q as a product of elementary
          reflectors (see Further Details).
  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.
  IPIV    (local output) INTEGER array, dimension LOCc(JA+N-1).
          On exit, if IPIV(I) = K, the local i-th column of sub( A )*P
          was the global K-th column of sub( A ). IPIV is tied to the
          distributed matrix A.
  TAU     (local output) COMPLEX*16, array, dimension
          LOCc(JA+MIN(M,N)-1). This array contains the scalar factors
          TAU of the elementary reflectors. TAU is tied to the
          distributed matrix A.
  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
          LWORK >= MAX(3,Mp0 + Nq0).
          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.
  RWORK   (local workspace/local output) DOUBLE PRECISION array,
                                                 dimension (LRWORK)
          On exit, RWORK(1) returns the minimal and optimal LRWORK.
  LRWORK  (local or global input) INTEGER
          The dimension of the array RWORK.
          LRWORK is local input and must be at least
          LRWORK >= LOCc(JA+N-1)+Nq0.
          IROFF = MOD( IA-1, MB_A ), ICOFF = MOD( JA-1, NB_A ),
          IAROW = INDXG2P( IA, MB_A, MYROW, RSRC_A, NPROW ),
          IACOL = INDXG2P( JA, NB_A, MYCOL, CSRC_A, NPCOL ),
          Mp0   = NUMROC( M+IROFF, MB_A, MYROW, IAROW, NPROW ),
          Nq0   = NUMROC( N+ICOFF, NB_A, MYCOL, IACOL, NPCOL ),
          LOCc(JA+N-1) = NUMROC( JA+N-1, NB_A, MYCOL, CSRC_A, NPCOL )
          and NUMROC, INDXG2P are ScaLAPACK tool functions;
          MYROW, MYCOL, NPROW and NPCOL can be determined by calling
          the subroutine BLACS_GRIDINFO.
          If LRWORK = -1, then LRWORK 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.
  Further Details
  ===============
  The matrix Q is represented as a product of elementary reflectors
     Q = H(1) H(2) . . . H(n)
  Each H(i) has the form
     H = I - tau * v * v'
  where tau is a complex scalar, and v is a complex vector with
  v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in
  A(ia+i-1:ia+m-1,ja+i-1).
  The matrix P is represented in jpvt as follows: If
     jpvt(j) = i
  then the jth column of P is the ith canonical unit vector.
  =====================================================================
     .. Parameters ..

Display dynamic version

FontSize: - +

001        SUBROUTINE PZGEQPF( M , N , A , IA , JA , DESCA , IPIV , TAU , WORK ,
002       $LWORK , RWORK , LRWORK , INFO )
003  
004  *     -- ScaLAPACK routine(version 1.7) --
005  *     University of Tennessee , Knoxville , Oak Ridge National Laboratory ,
006  *     and University of California , Berkeley.
007  *     March 14 , 2000
008  
009  *     .. Scalar Arguments ..
010        INTEGER IA , JA , INFO , LRWORK , LWORK , M , N
011        INTEGER BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ ,
012       $LLD_ , MB_ , M_ , NB_ , N_ , RSRC_
013        PARAMETER( BLOCK_CYCLIC_2D = 1 , DLEN_ = 9 , DTYPE_ = 1 ,
014       $CTXT_ = 2 , M_ = 3 , N_ = 4 , MB_ = 5 , NB_ = 6 ,
015       $RSRC_ = 7 , CSRC_ = 8 , LLD_ = 9 )
016        DOUBLE PRECISION ONE , ZERO
017        PARAMETER( ONE = 1.0D + 0 , ZERO = 0.0D + 0 )
018  *     ..
019  *     .. Local Scalars ..
020        LOGICAL LQUERY
021        INTEGER I , IACOL , IAROW , ICOFF , ICTXT , ICURROW ,
022       $ICURCOL , II , IIA , IOFFA , IPCOL , IROFF , ITEMP ,
023       $J , JB , JJ , JJA , JJPVT , JN , KB , K , KK , KSTART ,
024       $KSTEP , LDA , LL , LRWMIN , LWMIN , MN , MP , MYCOL ,
025       $MYROW , NPCOL , NPROW , NQ , NQ0 , PVT
026        DOUBLE PRECISION TEMP , TEMP2
027        COMPLEX*16 AJJ , ALPHA
028  *     ..
029  *     .. Local Arrays ..
030        INTEGER DESCN( DLEN_ ) , IDUM1( 2 ) , IDUM2( 2 )
031  *     ..
032  *     .. External Subroutines ..
033        EXTERNAL BLACS_GRIDINFO , CHK1MAT , DESCSET , IGERV2D ,
034       $IGESD2D , INFOG1L , INFOG2L , PCHK1MAT , PDAMAX ,
035       $PDZNRM2 , PXERBLA , PZELSET ,
036       $PZLARFC , PZLARFG , ZCOPY , ZGEBR2D ,
037       $ZGEBS2D , ZGERV2D , ZGESD2D , ZLARFG ,
038       $ZSWAP
039  *     ..
040  *     .. External Functions ..
041        INTEGER ICEIL , INDXG2P , NUMROC
042        EXTERNAL ICEIL , INDXG2P , NUMROC
043  *     ..
044  *     .. Intrinsic Functions ..
045        INTRINSIC ABS , DCMPLX , DCONJG , IDINT , MAX , MIN , MOD , SQRT
046  *     ..
047  *     .. Executable Statements ..
048  
049  *     Get grid parameters
050  
051        ICTXT = DESCA( CTXT_ )
052        CALL BLACS_GRIDINFO( ICTXT , NPROW , NPCOL , MYROW , MYCOL )
053  
054  *     Test the input parameters
055  
056        INFO = 0
057        IF( NPROW.EQ. - 1 ) THEN
057               
058            INFO = - (600 + CTXT_)
059        ELSE
059               
060            CALL CHK1MAT( M , 1 , N , 2 , IA , JA , DESCA , 6 , INFO )
061            IF( INFO.EQ.0 ) THEN
061                   
062                IROFF = MOD( IA - 1 , DESCA( MB_ ) )
063                ICOFF = MOD( JA - 1 , DESCA( NB_ ) )
064                IAROW = INDXG2P( IA , DESCA( MB_ ) , MYROW , DESCA( RSRC_ ) ,
065       $        NPROW )
066                IACOL = INDXG2P( JA , DESCA( NB_ ) , MYCOL , DESCA( CSRC_ ) ,
067       $        NPCOL )
068                MP = NUMROC( M + IROFF , DESCA( MB_ ) , MYROW , IAROW , NPROW )
069                NQ = NUMROC( N + ICOFF , DESCA( NB_ ) , MYCOL , IACOL , NPCOL )
070                NQ0 = NUMROC( JA + N - 1 , DESCA( NB_ ) , MYCOL , DESCA( CSRC_ ) ,
071       $        NPCOL )
072                LWMIN = MAX( 3 , MP + NQ )
073                LRWMIN = NQ0 + NQ
074  
075                WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )
076                RWORK( 1 ) = DBLE( LRWMIN )
077                LQUERY =( LWORK.EQ. - 1 .OR. LRWORK.EQ. - 1 )
078                IF( LWORK.LT.LWMIN .AND. .NOT.LQUERY ) THEN
078                       
079                    INFO = - 10
080                ELSE IF( LRWORK.LT.LRWMIN .AND. .NOT.LQUERY ) THEN
080                       
081                    INFO = - 12
082                END IF
083            END IF
084            IF( LWORK.EQ. - 1 ) THEN
084                   
085                IDUM1( 1 ) = - 1
086            ELSE
086                   
087                IDUM1( 1 ) = 1
088            END IF
089            IDUM2( 1 ) = 10
090            IF( LRWORK.EQ. - 1 ) THEN
090                   
091                IDUM1( 2 ) = - 1
092            ELSE
092                   
093                IDUM1( 2 ) = 1
094            END IF
095            IDUM2( 2 ) = 12
096            CALL PCHK1MAT( M , 1 , N , 2 , IA , JA , DESCA , 6 , 2 , IDUM1 , IDUM2 ,
097       $    INFO )
098        END IF
099  
100        IF( INFO.NE.0 ) THEN
100               
101            CALL PXERBLA( ICTXT , 'PZGEQPF' , - INFO )
102            RETURN
103        ELSE IF( LQUERY ) THEN
103               
104            RETURN
105        END IF
106  
107  *     Quick return if possible
108  
109        IF( M.EQ.0 .OR. N.EQ.0 )
109               
110       $    RETURN
111  
112            CALL INFOG2L( IA , JA , DESCA , NPROW , NPCOL , MYROW , MYCOL , IIA , JJA ,
113       $    IAROW , IACOL )
114            IF( MYROW.EQ.IAROW )
114                   
115       $        MP = MP - IROFF
116                IF( MYCOL.EQ.IACOL )
116                       
117       $            NQ = NQ - ICOFF
118                    MN = MIN( M , N )
119  
120  *                 Initialize the array of pivots
121  
122                    LDA = DESCA( LLD_ )
123                    JN = MIN( ICEIL( JA , DESCA( NB_ ) ) * DESCA( NB_ ) , JA + N - 1 )
124                    KSTEP = NPCOL * DESCA( NB_ )
125  
126                    IF( MYCOL.EQ.IACOL ) THEN
127  
128  *                     Handle first block separately
129  
129                           
130                        JB = JN - JA + 1
131                        DO 10 LL = JJA , JJA + JB - 1
131                               
132                            IPIV( LL ) = JA + LL - JJA
133     10                 CONTINUE
133                           
134                        KSTART = JN + KSTEP - DESCA( NB_ )
135  
136  *                     Loop over remaining block of columns
137  
138                        DO 30 KK = JJA + JB , JJA + NQ - 1 , DESCA( NB_ )
138                               
139                            KB = MIN( JJA + NQ - KK , DESCA( NB_ ) )
140                            DO 20 LL = KK , KK + KB - 1
140                                   
141                                IPIV( LL ) = KSTART + LL - KK + 1
142     20                     CONTINUE
142                               
143                            KSTART = KSTART + KSTEP
144     30                 CONTINUE
144                       
145                    ELSE
145                           
146                        KSTART = JN + ( MOD( MYCOL - IACOL + NPCOL , NPCOL ) - 1 )*
147       $                DESCA( NB_ )
148                        DO 50 KK = JJA , JJA + NQ - 1 , DESCA( NB_ )
148                               
149                            KB = MIN( JJA + NQ - KK , DESCA( NB_ ) )
150                            DO 40 LL = KK , KK + KB - 1
150                                   
151                                IPIV( LL ) = KSTART + LL - KK + 1
152     40                     CONTINUE
152                               
153                            KSTART = KSTART + KSTEP
154     50                 CONTINUE
154                       
155                    END IF
156  
157  *                 Initialize partial column norms , handle first block separately
158  
159                    CALL DESCSET( DESCN , 1 , DESCA( N_ ) , 1 , DESCA( NB_ ) , MYROW ,
160       $            DESCA( CSRC_ ) , ICTXT , 1 )
161  
162                    JJ = JJA
163                    IF( MYCOL.EQ.IACOL ) THEN
163                           
164                        DO 60 KK = 0 , JB - 1
164                               
165                            CALL PDZNRM2( M , RWORK( JJ + KK ) , A , IA , JA + KK , DESCA , 1 )
166                            RWORK( NQ + JJ + KK ) = RWORK( JJ + KK )
167     60                 CONTINUE
167                           
168                        JJ = JJ + JB
169                    END IF
170                    ICURCOL = MOD( IACOL + 1 , NPCOL )
171  
172  *                 Loop over the remaining blocks of columns
173  
174                    DO 80 J = JN + 1 , JA + N - 1 , DESCA( NB_ )
174                           
175                        JB = MIN( JA + N - J , DESCA( NB_ ) )
176  
177                        IF( MYCOL.EQ.ICURCOL ) THEN
177                               
178                            DO 70 KK = 0 , JB - 1
178                                   
179                                CALL PDZNRM2( M , RWORK( JJ + KK ) , A , IA , J + KK , DESCA , 1 )
180                                RWORK( NQ + JJ + KK ) = RWORK( JJ + KK )
181     70                     CONTINUE
181                               
182                            JJ = JJ + JB
183                        END IF
184                        ICURCOL = MOD( ICURCOL + 1 , NPCOL )
185     80             CONTINUE
186  
187  *                 Compute factorization
188  
188                       
189                    DO 120 J = JA , JA + MN - 1
189                           
190                        I = IA + J - JA
191  
192                        CALL INFOG1L( J , DESCA( NB_ ) , NPCOL , MYCOL , DESCA( CSRC_ ) ,
193       $                JJ , ICURCOL )
194                        K = JA + N - J
195                        IF( K.GT.1 ) THEN
195                               
196                            CALL PDAMAX( K , TEMP , PVT , RWORK , 1 , J , DESCN ,
197       $                    DESCN( M_ ) )
198                        ELSE
198                               
199                            PVT = J
200                        END IF
201                        IF( J.NE.PVT ) THEN
201                               
202                            CALL INFOG1L( PVT , DESCA( NB_ ) , NPCOL , MYCOL ,
203       $                    DESCA( CSRC_ ) , JJPVT , IPCOL )
204                            IF( ICURCOL.EQ.IPCOL ) THEN
204                                   
205                                IF( MYCOL.EQ.ICURCOL ) THEN
205                                       
206                                    CALL ZSWAP( MP , A( IIA + (JJ - 1)*LDA ) , 1 ,
207       $                            A( IIA + (JJPVT - 1)*LDA ) , 1 )
208                                    ITEMP = IPIV( JJPVT )
209                                    IPIV( JJPVT ) = IPIV( JJ )
210                                    IPIV( JJ ) = ITEMP
211                                    RWORK( JJPVT ) = RWORK( JJ )
212                                    RWORK( NQ + JJPVT ) = RWORK( NQ + JJ )
213                                END IF
214                            ELSE
214                                   
215                                IF( MYCOL.EQ.ICURCOL ) THEN
216  
216                                       
217                                    CALL ZGESD2D( ICTXT , MP , 1 , A( IIA + (JJ - 1)*LDA ) , LDA ,
218       $                            MYROW , IPCOL )
219                                    WORK( 1 ) = DCMPLX( DBLE( IPIV( JJ ) ) )
220                                    WORK( 2 ) = DCMPLX( RWORK( JJ ) )
221                                    WORK( 3 ) = DCMPLX( RWORK( JJ + NQ ) )
222                                    CALL ZGESD2D( ICTXT , 3 , 1 , WORK , 3 , MYROW , IPCOL )
223  
224                                    CALL ZGERV2D( ICTXT , MP , 1 , A( IIA + (JJ - 1)*LDA ) , LDA ,
225       $                            MYROW , IPCOL )
226                                    CALL IGERV2D( ICTXT , 1 , 1 , IPIV( JJ ) , 1 , MYROW ,
227       $                            IPCOL )
228  
229                                ELSE IF( MYCOL.EQ.IPCOL ) THEN
230  
230                                       
231                                    CALL ZGESD2D( ICTXT , MP , 1 , A( IIA + (JJPVT - 1)*LDA ) ,
232       $                            LDA , MYROW , ICURCOL )
233                                    CALL IGESD2D( ICTXT , 1 , 1 , IPIV( JJPVT ) , 1 , MYROW ,
234       $                            ICURCOL )
235  
236                                    CALL ZGERV2D( ICTXT , MP , 1 , A( IIA + (JJPVT - 1)*LDA ) ,
237       $                            LDA , MYROW , ICURCOL )
238                                    CALL ZGERV2D( ICTXT , 3 , 1 , WORK , 3 , MYROW , ICURCOL )
239                                    IPIV( JJPVT ) = IDINT( DBLE( WORK( 1 ) ) )
240                                    RWORK( JJPVT ) = DBLE( WORK( 2 ) )
241                                    RWORK( JJPVT + NQ ) = DBLE( WORK( 3 ) )
242  
243                                END IF
244  
245                            END IF
246  
247                        END IF
248  
249  *                     Generate elementary reflector H(i)
250  
251                        CALL INFOG1L( I , DESCA( MB_ ) , NPROW , MYROW , DESCA( RSRC_ ) ,
252       $                II , ICURROW )
253                        IF( DESCA( M_ ).EQ.1 ) THEN
253                               
254                            IF( MYROW.EQ.ICURROW ) THEN
254                                   
255                                IF( MYCOL.EQ.ICURCOL ) THEN
255                                       
256                                    IOFFA = II + (JJ - 1)*DESCA( LLD_ )
257                                    AJJ = A( IOFFA )
258                                    CALL ZLARFG( 1 , AJJ , A( IOFFA ) , 1 , TAU( JJ ) )
259                                    IF( N.GT.1 ) THEN
259                                           
260                                        ALPHA = CMPLX( ONE ) - DCONJG( TAU( JJ ) )
261                                        CALL ZGEBS2D( ICTXT , 'Rowwise' , ' ' , 1 , 1 , ALPHA ,
262       $                                1 )
263                                        CALL ZSCAL( NQ - JJ , ALPHA , A( IOFFA + DESCA( LLD_ ) ) ,
264       $                                DESCA( LLD_ ) )
265                                    END IF
266                                    CALL ZGEBS2D( ICTXT , 'Columnwise' , ' ' , 1 , 1 ,
267       $                            TAU( JJ ) , 1 )
268                                    A( IOFFA ) = AJJ
269                                ELSE
269                                       
270                                    IF( N.GT.1 ) THEN
270                                           
271                                        CALL ZGEBR2D( ICTXT , 'Rowwise' , ' ' , 1 , 1 , ALPHA ,
272       $                                1 , ICURROW , ICURCOL )
273                                        CALL ZSCAL( NQ - JJ + 1 , ALPHA , A( I ) , DESCA( LLD_ ) )
274                                    END IF
275                                END IF
276                            ELSE IF( MYCOL.EQ.ICURCOL ) THEN
276                                   
277                                CALL ZGEBR2D( ICTXT , 'Columnwise' , ' ' , 1 , 1 , TAU( JJ ) ,
278       $                        1 , ICURROW , ICURCOL )
279                            END IF
280  
281                        ELSE
282  
282                               
283                            CALL PZLARFG ( M - J + JA , AJJ , I , J , A , MIN( I + 1 , IA + M - 1 ) , J ,
284       $                    DESCA , 1 , TAU )
285                            IF( J.LT.JA + N - 1 ) THEN
286  
287  *                             Apply H(i) to A(ia + j - ja : ia + m - 1 , j + 1 : ja + n - 1) from the left
288  
288                                   
289                                CALL PZELSET( A , I , J , DESCA , DCMPLX( ONE ) )
290                                CALL PZLARFC ( 'Left' , M - J + JA , JA + N - 1 - J , A , I , J , DESCA ,
291       $                        1 , TAU , A , I , J + 1 , DESCA , WORK )
292                            END IF
293                            CALL PZELSET( A , I , J , DESCA , AJJ )
294  
295                        END IF
296  
297  *                     Update partial columns norms
298  
299                        IF( MYCOL.EQ.ICURCOL )
299                               
300       $                    JJ = JJ + 1
301                            IF( MOD( J , DESCA( NB_ ) ).EQ.0 )
301                                   
302       $                        ICURCOL = MOD( ICURCOL + 1 , NPCOL )
303                                IF((JJA + NQ - JJ).GT.0 ) THEN
303                                       
304                                    IF( MYROW.EQ.ICURROW ) THEN
304                                           
305                                        CALL ZGEBS2D( ICTXT , 'Columnwise' , ' ' , 1 , JJA + NQ - JJ ,
306       $                                A( II + ( MIN( JJA + NQ - 1 , JJ ) - 1 )*LDA ) ,
307       $                                LDA )
308                                        CALL ZCOPY( JJA + NQ - JJ , A( II + ( MIN( JJA + NQ - 1 , JJ )
309       $                                - 1)*LDA ) , LDA , WORK( MIN( JJA + NQ - 1 , JJ ) ) ,
310       $                                1 )
311                                    ELSE
311                                           
312                                        CALL ZGEBR2D( ICTXT , 'Columnwise' , ' ' , JJA + NQ - JJ , 1 ,
313       $                                WORK( MIN( JJA + NQ - 1 , JJ ) ) , MAX( 1 , NQ ) ,
314       $                                ICURROW , MYCOL )
315                                    END IF
316                                END IF
317  
318                                JN = MIN( ICEIL( J + 1 , DESCA( NB_ ) ) * DESCA( NB_ ) ,
319       $                        JA + N - 1 )
320                                IF( MYCOL.EQ.ICURCOL ) THEN
320                                       
321                                    DO 90 LL = JJ , JJ + JN - J - 1
321                                           
322                                        IF( RWORK( LL ).NE.ZERO ) THEN
322                                               
323                                            TEMP = ONE - ( ABS( WORK( LL ) ) / RWORK( LL ) )**2
324                                            TEMP = MAX( TEMP , ZERO )
325                                            TEMP2 = ONE + 0.05D + 0*TEMP*
326       $( RWORK( LL ) / RWORK( NQ + LL ) )**2
326                                               
327                                            IF( TEMP2.EQ.ONE ) THEN
327                                                   
328                                                IF( IA + M - 1.GT.I ) THEN
328                                                       
329                                                    CALL PDZNRM2( IA + M - I - 1 , RWORK( LL ) , A ,
330       $                                            I + 1 , J + LL - JJ , DESCA , 1 )
331                                                    RWORK( NQ + LL ) = RWORK( LL )
332                                                ELSE
332                                                       
333                                                    RWORK( LL ) = ZERO
334                                                    RWORK( NQ + LL ) = ZERO
335                                                END IF
336                                            ELSE
336                                                   
337                                                RWORK( LL ) = RWORK( LL ) * SQRT( TEMP )
338                                            END IF
339                                        END IF
340     90                             CONTINUE
340                                       
341                                    JJ = JJ + JN - J
342                                END IF
343                                ICURCOL = MOD( ICURCOL + 1 , NPCOL )
344  
345                                DO 110 K = JN + 1 , JA + N - 1 , DESCA( NB_ )
345                                       
346                                    KB = MIN( JA + N - K , DESCA( NB_ ) )
347  
348                                    IF( MYCOL.EQ.ICURCOL ) THEN
348                                           
349                                        DO 100 LL = JJ , JJ + KB - 1
349                                               
350                                            IF( RWORK(LL).NE.ZERO ) THEN
350                                                   
351                                                TEMP = ONE - ( ABS( WORK( LL ) ) / RWORK( LL ) )**2
352                                                TEMP = MAX( TEMP , ZERO )
353                                                TEMP2 = ONE + 0.05D + 0*TEMP*
354       $( RWORK( LL ) / RWORK( NQ + LL ) )**2
354                                                   
355                                                IF( TEMP2.EQ.ONE ) THEN
355                                                       
356                                                    IF( IA + M - 1.GT.I ) THEN
356                                                           
357                                                        CALL PDZNRM2( IA + M - I - 1 , RWORK( LL ) , A ,
358       $                                                I + 1 , K + LL - JJ , DESCA , 1 )
359                                                        RWORK( NQ + LL ) = RWORK( LL )
360                                                    ELSE
360                                                           
361                                                        RWORK( LL ) = ZERO
362                                                        RWORK( NQ + LL ) = ZERO
363                                                    END IF
364                                                ELSE
364                                                       
365                                                    RWORK( LL ) = RWORK( LL ) * SQRT( TEMP )
366                                                END IF
367                                            END IF
368    100                                 CONTINUE
368                                           
369                                        JJ = JJ + KB
370                                    END IF
371                                    ICURCOL = MOD( ICURCOL + 1 , NPCOL )
372  
373    110                         CONTINUE
374  
375    120             CONTINUE
376  
376                       
377                    WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )
378                    RWORK( 1 ) = DBLE( LRWMIN )
379  
380                    RETURN
381  
382  *                 End of PZGEQPF
383  
384                END3053

Variables in Routine PZGEQPF()

Summary Report
Data Type	Quantity	Size(byte)
*COMPLEX16**	2	?
DOUBLE PRECISION	4	16
INTEGER	62	260
LOGICAL	1	1
REAL	3	12
TOTAL	72	289

List of Variables

COMPLEX*16

AJJ ALPHA

DOUBLE PRECISION

ONE TEMP TEMP2 ZERO

INTEGER

BLOCK_CYCLIC_2D CSRC_ CTXT_ DESCN( DLEN_ ) DLEN_
DTYPE_ I IA IACOL IAROW
ICEIL ICOFF ICTXT ICURCOL ICURROW
IDUM1( 2 ) IDUM2( 2 ) II IIA INDXG2P
INFO IOFFA IPCOL IPIV IROFF
ITEMP J JA JB JJ
JJA JJPVT JN K KB
KK KSTART KSTEP LDA LL
LLD_ LRWMIN LRWORK LWMIN LWORK
M M_ MB_ MN MP
MYCOL MYROW N N_ NB_
NPCOL NPROW NQ NQ0 NUMROC
PVT RSRC_

LOGICAL

LQUERY

REAL

A RWORK WORK

Variables Dependence Graph
Put the mouse over a right hand side variable to display the corresponding line of the dependence
-
- -
A <--- AJJA( IOFFA ) = AJJ

AJJ <--- AAJJ = A( IOFFA ), IOFFAAJJ = A( IOFFA )

ALPHA <--- JJ, ONE

I <--- IAI = IA + J - JA, JI = IA + J - JA, JAI = IA + J - JA

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

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

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

ICTXT <--- CTXT_ICTXT = DESCA( CTXT_ )

ICURCOL <--- IACOLICURCOL = MOD( IACOL+1, NPCOL ), ICURCOLICURCOL = MOD( ICURCOL+1, NPCOL ){2ICURCOL = MOD( ICURCOL+1, NPCOL ), 3ICURCOL = MOD( ICURCOL+1, NPCOL )}, NPCOLICURCOL = MOD( IACOL+1, NPCOL ){2ICURCOL = MOD( ICURCOL+1, NPCOL ), 3ICURCOL = MOD( ICURCOL+1, NPCOL ), 4ICURCOL = MOD( ICURCOL+1, NPCOL )}

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

IOFFA <--- IIIOFFA = II+(JJ-1)*DESCA( LLD_ ), JJIOFFA = II+(JJ-1)*DESCA( LLD_ ), LLD_IOFFA = II+(JJ-1)*DESCA( LLD_ )

IPIV <--- IPIVIPIV( JJPVT ) = IPIV( JJ ), ITEMPIPIV( JJ ) = ITEMP, JAIPIV( LL ) = JA + LL - JJA, JJIPIV( JJPVT ) = IPIV( JJ ), JJAIPIV( LL ) = JA + LL - JJA, KKIPIV( LL ) = KSTART+LL-KK+1{2IPIV( LL ) = KSTART+LL-KK+1}, KSTARTIPIV( LL ) = KSTART+LL-KK+1{2IPIV( LL ) = KSTART+LL-KK+1}, LLIPIV( LL ) = JA + LL - JJA{2IPIV( LL ) = KSTART+LL-KK+1, 3IPIV( LL ) = KSTART+LL-KK+1}, WORK

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

ITEMP <--- IPIVITEMP = IPIV( JJPVT ), JJPVTITEMP = IPIV( JJPVT )

J <--- JADO 80 J = JN+1, JA+N-1, DESCA( NB_ ){2DO 120 J = JA, JA+MN-1}, JNDO 80 J = JN+1, JA+N-1, DESCA( NB_ ), MNDO 120 J = JA, JA+MN-1, NDO 80 J = JN+1, JA+N-1, DESCA( NB_ ), NB_DO 80 J = JN+1, JA+N-1, DESCA( NB_ )

JB <--- JJB = MIN( JA+N-J, DESCA( NB_ ) ), JAJB = JN - JA + 1{2JB = MIN( JA+N-J, DESCA( NB_ ) )}, JNJB = JN - JA + 1, NJB = MIN( JA+N-J, DESCA( NB_ ) ), NB_JB = MIN( JA+N-J, DESCA( NB_ ) )

JJ <--- JJJ = JJ + JN - J, JBJJ = JJ + JB{2JJ = JJ + JB}, JJJJ = JJ + JB{2JJ = JJ + JB, 3JJ = JJ + JN - J, 4JJ = JJ + KB}, JJAJJ = JJA, JNJJ = JJ + JN - J, KBJJ = JJ + KB

JN <--- ICEIL{2}, J, JA{2}, N{2}, NB_{2}

K <--- JK = JA + N - J, JAK = JA + N - J{2DO 110 K = JN+1, JA+N-1, DESCA( NB_ )}, JNDO 110 K = JN+1, JA+N-1, DESCA( NB_ ), NK = JA + N - J{2DO 110 K = JN+1, JA+N-1, DESCA( NB_ )}, NB_DO 110 K = JN+1, JA+N-1, DESCA( NB_ )

KB <--- JAKB = MIN( JA+N-K, DESCA( NB_ ) ), JJAKB = MIN( JJA+NQ-KK, DESCA( NB_ ) ){2KB = MIN( JJA+NQ-KK, DESCA( NB_ ) )}, KKB = MIN( JA+N-K, DESCA( NB_ ) ), KKKB = MIN( JJA+NQ-KK, DESCA( NB_ ) ){2KB = MIN( JJA+NQ-KK, DESCA( NB_ ) )}, NKB = MIN( JA+N-K, DESCA( NB_ ) ), NB_KB = MIN( JJA+NQ-KK, DESCA( NB_ ) ){2KB = MIN( JJA+NQ-KK, DESCA( NB_ ) ), 3KB = MIN( JA+N-K, DESCA( NB_ ) )}, NQKB = MIN( JJA+NQ-KK, DESCA( NB_ ) ){2KB = MIN( JJA+NQ-KK, DESCA( NB_ ) )}

KK <--- JB{2DO 60 KK = 0, JB-1, 3DO 70 KK = 0, JB-1}, JJA{2DO 50 KK = JJA, JJA+NQ-1, DESCA( NB_ )}, NB_{2DO 50 KK = JJA, JJA+NQ-1, DESCA( NB_ )}, NQ{2DO 50 KK = JJA, JJA+NQ-1, DESCA( NB_ )}

KSTART <--- IACOL, JNKSTART = JN + KSTEP - DESCA( NB_ ){2}, KSTARTKSTART = KSTART + KSTEP{2KSTART = KSTART + KSTEP}, KSTEPKSTART = JN + KSTEP - DESCA( NB_ ){2KSTART = KSTART + KSTEP, 3KSTART = KSTART + KSTEP}, MYCOL, NB_KSTART = JN + KSTEP - DESCA( NB_ ){2}, NPCOL

KSTEP <--- NB_KSTEP = NPCOL * DESCA( NB_ ), NPCOLKSTEP = NPCOL * DESCA( NB_ )

LDA <--- LLD_LDA = DESCA( LLD_ )

LL <--- JDO 90 LL = JJ, JJ + JN - J - 1, JBDO 10 LL = JJA, JJA+JB-1, JJDO 90 LL = JJ, JJ + JN - J - 1{2DO 100 LL = JJ, JJ+KB-1}, JJADO 10 LL = JJA, JJA+JB-1, JNDO 90 LL = JJ, JJ + JN - J - 1, KBDO 20 LL = KK, KK+KB-1{2DO 40 LL = KK, KK+KB-1, 3DO 100 LL = JJ, JJ+KB-1}, KKDO 20 LL = KK, KK+KB-1{2DO 40 LL = KK, KK+KB-1}

LRWMIN <--- NQLRWMIN = NQ0 + NQ, NQ0LRWMIN = NQ0 + NQ

LWMIN <--- MPLWMIN = MAX( 3, MP + NQ ), NQLWMIN = MAX( 3, MP + NQ )

MN <--- MMN = MIN( M, N ), NMN = MIN( M, N )

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

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

NQ0 <--- JA, CSRC_, MYCOL, N, NB_, NPCOL, NUMROC

PVT <--- JPVT = J

RWORK <--- JJRWORK( NQ+JJ+KK ) = RWORK( JJ+KK ){2RWORK( NQ+JJ+KK ) = RWORK( JJ+KK ), 3RWORK( JJPVT ) = RWORK( JJ ), 4RWORK( NQ+JJPVT ) = RWORK( NQ+JJ )}, KKRWORK( NQ+JJ+KK ) = RWORK( JJ+KK ){2RWORK( NQ+JJ+KK ) = RWORK( JJ+KK )}, LLRWORK( NQ+LL ) = RWORK( LL ){2, 3RWORK( NQ+LL ) = RWORK( LL ), 4}, LRWMINRWORK( 1 ) = DBLE( LRWMIN ){2RWORK( 1 ) = DBLE( LRWMIN )}, NQRWORK( NQ+JJPVT ) = RWORK( NQ+JJ ), RWORKRWORK( NQ+JJ+KK ) = RWORK( JJ+KK ){2RWORK( NQ+JJ+KK ) = RWORK( JJ+KK ), 3RWORK( JJPVT ) = RWORK( JJ ), 4RWORK( NQ+JJPVT ) = RWORK( NQ+JJ ), 5RWORK( NQ+LL ) = RWORK( LL ), 6, 7RWORK( NQ+LL ) = RWORK( LL ), 8}, TEMP{2}, WORKRWORK( JJPVT ) = DBLE( WORK( 2 ) ){2RWORK( JJPVT+NQ ) = DBLE( WORK( 3 ) )}, ZERORWORK( LL ) = ZERO{2RWORK( NQ+LL ) = ZERO, 3RWORK( LL ) = ZERO, 4RWORK( NQ+LL ) = ZERO}

TEMP <--- LL{2}, ONE{2}, RWORK{2}, TEMPTEMP = MAX( TEMP, ZERO ){2TEMP = MAX( TEMP, ZERO )}, WORK{2}, ZEROTEMP = MAX( TEMP, ZERO ){2TEMP = MAX( TEMP, ZERO )}

TEMP2 <--- LLTEMP2 = ONE + 0.05D+0*TEMP*{2TEMP2 = ONE + 0.05D+0*TEMP*}, NQTEMP2 = ONE + 0.05D+0*TEMP*{2TEMP2 = ONE + 0.05D+0*TEMP*}, ONETEMP2 = ONE + 0.05D+0*TEMP*{2TEMP2 = ONE + 0.05D+0*TEMP*}, RWORKTEMP2 = ONE + 0.05D+0*TEMP*{2TEMP2 = ONE + 0.05D+0*TEMP*}, TEMPTEMP2 = ONE + 0.05D+0*TEMP*{2TEMP2 = ONE + 0.05D+0*TEMP*}

WORK <--- IPIV, JJ{2WORK( 2 ) = DCMPLX( RWORK( JJ ) ), 3WORK( 3 ) = DCMPLX( RWORK( JJ + NQ ) )}, LWMINWORK( 1 ) = DCMPLX( DBLE( LWMIN ) ){2WORK( 1 ) = DCMPLX( DBLE( LWMIN ) )}, NQWORK( 3 ) = DCMPLX( RWORK( JJ + NQ ) ), RWORKWORK( 2 ) = DCMPLX( RWORK( JJ ) ){2WORK( 3 ) = DCMPLX( RWORK( JJ + NQ ) )}

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

Assigned variables
		AJJ , ALPHA , BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DLEN_ , DTYPE_ , I , IACOL , IAROW , ICOFF , ICTXT , ICURCOL , IDUM1 , IDUM2 , INFO , IOFFA , IROFF , ITEMP , J , JB , JJ , JJPVT , JN , K , KB , KK , KSTART , KSTEP , LDA , LL , LLD_ , LQUERY , LRWMIN , LWMIN , M_ , MB_ , MN , MP , N_ , NB_ , NQ , NQ0 , ONE , PVT , RSRC_ , RWORK , TEMP , TEMP2 , WORK , ZERO

Active variables
		A , AJJ , ALPHA , BLOCK_CYCLIC_2D , CSRC_ , CTXT_ , DESCA , DESCN , DLEN_ , DTYPE_ , I , IA , IACOL , IAROW , ICEIL , ICOFF , ICTXT , ICURCOL , ICURROW , IDUM1 , IDUM2 , II , IIA , INDXG2P , INFO , IOFFA , IPCOL , IPIV , IROFF , ITEMP , J , JA , JB , JJ , JJA , JJPVT , JN , K , KB , KK , KSTART , KSTEP , LDA , LL , LLD_ , LQUERY , LRWMIN , LRWORK , LWMIN , LWORK , M , M_ , MB_ , MN , MP , MYCOL , MYROW , N , N_ , NB_ , NPCOL , NPROW , NQ , NQ0 , NUMROC , ONE , PVT , RSRC_ , RWORK , TAU , TEMP , TEMP2 , WORK , ZERO

Accessed arrays [ array name : associated index ]
	A	: I , ia+j-ja:ia+m-1,j+1:ja+n-1 , II+( MIN( JJA+NQ-1, JJ )-1 )LDA , IIA+(JJ-1)LDA , IIA+(JJ-1)LDA , IIA+(JJ-1)LDA , IIA+(JJPVT-1)LDA , IIA+(JJPVT-1)LDA , IIA+(JJPVT-1)*LDA , IOFFA , IOFFA , IOFFA , IOFFA+DESCA( LLD_ )
	DESCA	: CSRC_ , CSRC_ , CSRC_ , CSRC_ , CSRC_ , CTXT_ , LLD_ , LLD_ , LLD_ , LLD_ , LLD_ , M_ , MB_ , MB_ , MB_ , MB_ , N_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , NB_ , RSRC_ , RSRC_
	DESCN	: DLEN_ , M_
	ICEIL	: J+1, DESCA( NB_ ) , JA, DESCA( NB_ )
	IDUM1	: 1 , 1 , 2 , 2 , 2
	IDUM2	: 1 , 2 , 2
	IPIV	: JJ , JJ , JJ , JJ , JJPVT , JJPVT , JJPVT , JJPVT , LL , LL , LL
	NUMROC	: M+IROFF, DESCA( MB_ ), MYROW, IAROW, NPROW , N+ICOFF, DESCA( NB_ ), MYCOL, IACOL, NPCOL
	RWORK	: 1 , 1 , JJ + NQ , JJ , JJ , JJ+KK , JJ+KK , JJ+KK , JJ+KK , JJPVT , JJPVT , JJPVT+NQ , LL , LL , LL , LL , LL , LL , LL , LL , LL , LL , LL , LL , LL , LL , NQ+JJ , NQ+JJ+KK , NQ+JJ+KK , NQ+JJPVT , NQ+LL , NQ+LL , NQ+LL , NQ+LL , NQ+LL , NQ+LL
	TAU	: JJ , JJ , JJ , JJ
	WORK	: 1 , 1 , 1 , 1 , 2 , 2 , 3 , 3 , LL , LL , MIN( JJA+NQ-1, JJ ) , MIN( JJA+NQ-1, JJ )

Conditional statements [ statement : associated predicate ]
	do	: `(` 10 LL = JJA , JJA + JB - 1 `)` , `(` 30 KK = JJA + JB , JJA + NQ - 1 , DESCA( NB_ ) `)` , `(` 20 LL = KK , KK + KB - 1 `)` , `(` 50 KK = JJA , JJA + NQ - 1 , DESCA( NB_ ) `)` , `(` 40 LL = KK , KK + KB - 1 `)` , `(` 60 KK = 0 , JB - 1 `)` , `(` 80 J = JN + 1 , JA + N - 1 , DESCA( NB_ ) `)` , `(` 70 KK = 0 , JB - 1 `)` , `(` 120 J = JA , JA + MN - 1 `)` , `(` 90 LL = JJ , JJ + JN - J - 1 `)` , `(` 110 K = JN + 1 , JA + N - 1 , DESCA( NB_ ) `)` , `(` 100 LL = JJ , JJ + KB - 1 `)`
	if	: `(` NPROW.EQ. - 1 `)` , `(` INFO.EQ.0 `)` , `(` LWORK.LT.LWMIN .AND. .NOT.LQUERY `)` , `(` LRWORK.LT.LRWMIN .AND. .NOT.LQUERY `)` , `(` LWORK.EQ. - 1 `)` , `(` LRWORK.EQ. - 1 `)` , `(` INFO.NE.0 `)` , `(` LQUERY `)` , `(` possible `)` , `(` M.EQ.0 .OR. N.EQ.0 `)` , `(` MYROW.EQ.IAROW `)` , `(` MYCOL.EQ.IACOL `)` , `(` MYCOL.EQ.IACOL `)` , `(` MYCOL.EQ.IACOL `)` , `(` MYCOL.EQ.ICURCOL `)` , `(` K.GT.1 `)` , `(` J.NE.PVT `)` , `(` ICURCOL.EQ.IPCOL `)` , `(` MYCOL.EQ.ICURCOL `)` , `(` MYCOL.EQ.ICURCOL `)` , `(` MYCOL.EQ.IPCOL `)` , `(` (DESCA( M_ ).EQ.1 ) `)` , `(` MYROW.EQ.ICURROW `)` , `(` MYCOL.EQ.ICURCOL `)` , `(` N.GT.1 `)` , `(` N.GT.1 `)` , `(` MYCOL.EQ.ICURCOL `)` , `(` J.LT.JA + N - 1 `)` , `(` MYCOL.EQ.ICURCOL `)` , `(` (MOD( J , DESCA( NB_ ) ).EQ.0 ) `)` , `(` ((JJA+NQ - JJ).GT.0 ) `)` , `(` MYROW.EQ.ICURROW `)` , `(` MYCOL.EQ.ICURCOL `)` , `(` (RWORK( LL ).NE.ZERO ) `)` , `(` TEMP2.EQ.ONE `)` , `(` IA+M-1.GT.I `)` , `(` MYCOL.EQ.ICURCOL `)` , `(` (RWORK(LL).NE.ZERO ) `)` , `(` TEMP2.EQ.ONE `)` , `(` IA+M-1.GT.I `)`