pdgeqpf()

subroutine pdgeqpf	(	integer	m,
		integer	n,
		double precision, dimension( * )	a,
		integer	ia,
		integer	ja,
		integer, dimension( * )	desca,
		integer, dimension( * )	ipiv,
		double precision, dimension( * )	tau,
		double precision, dimension( * )	work,
		integer	lwork,
		integer	info
	)

Definition at line 1 of file pdgeqpf.f.

*
*  -- ScaLAPACK routine (version 2.1) --
*     University of Tennessee, Knoxville, Oak Ridge National Laboratory,
*     and University of California, Berkeley.
*     November 20, 2019
*
*     .. Scalar Arguments ..
      INTEGER            IA, JA, INFO, LWORK, M, N
*     ..
*     .. Array Arguments ..
      INTEGER            DESCA( * ), IPIV( * )
      DOUBLE PRECISION   A( * ), TAU( * ), WORK( * )
*     ..
*
*  Purpose
*  =======
*
*  PDGEQPF 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) DOUBLE PRECISION 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 orthogonal 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) DOUBLE PRECISION 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) 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
*          LWORK >= MAX(3,Mp0 + Nq0) + 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 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.
*
*  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 real scalar, and v is a real 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.
*
*  References
*  ==========
*  
*  For modifications introduced in Scalapack 2.1
*  LAWN 295 
*  New robust ScaLAPACK routine for computing the QR factorization with column pivoting
*  Zvonimir Bujanovic, Zlatko Drmac
*  http://www.netlib.org/lapack/lawnspdf/lawn295.pdf
*
*  =====================================================================
*
*     .. Parameters ..
      INTEGER            BLOCK_CYCLIC_2D, CSRC_, CTXT_, DLEN_, DTYPE_,
     $                   LLD_, MB_, M_, NB_, N_, RSRC_
      parameter( block_cyclic_2d = 1, dlen_ = 9, dtype_ = 1,
     $                     ctxt_ = 2, m_ = 3, n_ = 4, mb_ = 5, nb_ = 6,
     $                     rsrc_ = 7, csrc_ = 8, lld_ = 9 )
      DOUBLE PRECISION   ONE, ZERO
      parameter( one = 1.0d+0, zero = 0.0d+0 )
*     ..
*     .. Local Scalars ..
      LOGICAL            LQUERY
      INTEGER            I, IACOL, IAROW, ICOFF, ICTXT, ICURROW,
     $                   ICURCOL, II, IIA, IOFFA, IPN, IPCOL, IPW,
     $                   IROFF, ITEMP, J, JB, JJ, JJA, JJPVT, JN, KB,
     $                   K, KK, KSTART, KSTEP, LDA, LL, LWMIN, MN, MP,
     $                   MYCOL, MYROW, NPCOL, NPROW, NQ, NQ0, PVT
      DOUBLE PRECISION   AJJ, ALPHA, TEMP, TEMP2, TOL3Z
*     ..
*     .. Local Arrays ..
      INTEGER            DESCN( DLEN_ ), IDUM1( 1 ), IDUM2( 1 )
*     ..
*     .. External Subroutines ..
      EXTERNAL           blacs_gridinfo, chk1mat, dcopy, descset,
     $                   dgebr2d, dgebs2d, dgerv2d,
     $                   dgesd2d, dlarfg, dswap, igerv2d,
     $                   igesd2d, infog1l, infog2l, pchk1mat, pdamax,
     $                   pdelset, pdlarf, pdlarfg, pdnrm2,
     $                   pxerbla
*     ..
*     .. External Functions ..
      INTEGER            ICEIL, INDXG2P, NUMROC
      EXTERNAL           iceil, indxg2p, numroc
      DOUBLE PRECISION   DLAMCH
      EXTERNAL           dlamch
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, dble, idint, max, min, mod, sqrt
*     ..
*     .. Executable Statements ..
*
*     Get grid parameters
*
      ictxt = desca( ctxt_ )
      CALL blacs_gridinfo( ictxt, nprow, npcol, myrow, mycol )
*
*     Test the input parameters
*
      info = 0
      IF( nprow.EQ.-1 ) THEN
         info = -(600+ctxt_)
      ELSE
         CALL chk1mat( m, 1, n, 2, ia, ja, desca, 6, info )
         IF( info.EQ.0 ) THEN
            iroff = mod( ia-1, desca( mb_ ) )
            icoff = mod( ja-1, desca( nb_ ) )
            iarow = indxg2p( ia, desca( mb_ ), myrow, desca( rsrc_ ),
     $                       nprow )
            iacol = indxg2p( ja, desca( nb_ ), mycol, desca( csrc_ ),
     $                       npcol )
            mp = numroc( m+iroff, desca( mb_ ), myrow, iarow, nprow )
            nq = numroc( n+icoff, desca( nb_ ), mycol, iacol, npcol )
            nq0 = numroc( ja+n-1, desca( nb_ ), mycol, desca( csrc_ ),
     $                    npcol )
            lwmin = max( 3, mp + nq ) + nq0 + nq
*
            work( 1 ) = dble( lwmin )
            lquery = ( lwork.EQ.-1 )
            IF( lwork.LT.lwmin .AND. .NOT.lquery )
     $         info = -10
         END IF
         IF( lwork.EQ.-1 ) THEN
            idum1( 1 ) = -1
         ELSE
            idum1( 1 ) = 1
         END IF
         idum2( 1 ) = 10
         CALL pchk1mat( m, 1, n, 2, ia, ja, desca, 6, 1, idum1, idum2,
     $                  info )
      END IF
*
      IF( info.NE.0 ) THEN
         CALL pxerbla( ictxt, 'PDGEQPF', -info )
         RETURN
      ELSE IF( lquery ) THEN
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( m.EQ.0 .OR. n.EQ.0 )
     $   RETURN
*
      CALL infog2l( ia, ja, desca, nprow, npcol, myrow, mycol, iia, jja,
     $              iarow, iacol )
      IF( myrow.EQ.iarow )
     $   mp = mp - iroff
      IF( mycol.EQ.iacol )
     $   nq = nq - icoff
      mn = min( m, n )
      tol3z = sqrt( dlamch('Epsilon') )
*
*     Initialize the array of pivots
*
      lda = desca( lld_ )
      jn = min( iceil( ja, desca( nb_ ) ) * desca( nb_ ), ja+n-1 )
      kstep  = npcol * desca( nb_ )
*
      IF( mycol.EQ.iacol ) THEN
*
*        Handle first block separately
*
         jb = jn - ja + 1
         DO 10 ll = jja, jja+jb-1
            ipiv( ll ) = ja + ll - jja
   10    CONTINUE
         kstart = jn + kstep - desca( nb_ )
*
*        Loop over remaining block of columns
*
         DO 30 kk = jja+jb, jja+nq-1, desca( nb_ )
            kb = min( jja+nq-kk, desca( nb_ ) )
            DO 20 ll = kk, kk+kb-1
               ipiv( ll ) = kstart+ll-kk+1
   20       CONTINUE
            kstart = kstart + kstep
   30    CONTINUE
      ELSE
         kstart = jn + ( mod( mycol-iacol+npcol, npcol )-1 )*
     $                        desca( nb_ )
         DO 50 kk = jja, jja+nq-1, desca( nb_ )
            kb = min( jja+nq-kk, desca( nb_ ) )
            DO 40 ll = kk, kk+kb-1
               ipiv( ll ) = kstart+ll-kk+1
   40       CONTINUE
            kstart = kstart + kstep
   50    CONTINUE
      END IF
*
*     Initialize partial column norms, handle first block separately
*
      CALL descset( descn, 1, desca( n_ ), 1, desca( nb_ ), myrow,
     $              desca( csrc_ ), ictxt, 1 )
*
      ipn = 1
      ipw = ipn + nq0 + nq
      jj = ipn + jja - 1
      IF( mycol.EQ.iacol ) THEN
         DO 60 kk = 0, jb-1
            CALL pdnrm2( m, work( jj+kk ), a, ia, ja+kk, desca, 1 )
            work( nq+jj+kk ) = work( jj+kk )
   60    CONTINUE
         jj = jj + jb
      END IF
      icurcol = mod( iacol+1, npcol )
*
*     Loop over the remaining blocks of columns
*
      DO 80 j = jn+1, ja+n-1, desca( nb_ )
         jb = min( ja+n-j, desca( nb_ ) )
*
         IF( mycol.EQ.icurcol ) THEN
            DO 70 kk = 0, jb-1
               CALL pdnrm2( m, work( jj+kk ), a, ia, j+kk, desca, 1 )
               work( nq+jj+kk ) = work( jj+kk )
   70       CONTINUE
            jj = jj + jb
         END IF
         icurcol = mod( icurcol+1, npcol )
   80 CONTINUE
*
*     Compute factorization
*
      DO 120 j = ja, ja+mn-1
         i = ia + j - ja
*
         CALL infog1l( j, desca( nb_ ), npcol, mycol, desca( csrc_ ),
     $                 jj, icurcol )
         k = ja + n - j
         IF( k.GT.1 ) THEN
            CALL pdamax( k, temp, pvt, work( ipn ), 1, j, descn,
     $                   descn( m_ ) )
         ELSE
            pvt = j
         END IF
         IF( j.NE.pvt ) THEN
            CALL infog1l( pvt, desca( nb_ ), npcol, mycol,
     $                    desca( csrc_ ), jjpvt, ipcol )
            IF( icurcol.EQ.ipcol ) THEN
               IF( mycol.EQ.icurcol ) THEN
                  CALL dswap( mp, a( iia+(jj-1)*lda ), 1,
     $                        a( iia+(jjpvt-1)*lda ), 1 )
                  itemp = ipiv( jjpvt )
                  ipiv( jjpvt ) = ipiv( jj )
                  ipiv( jj ) = itemp
                  work( ipn+jjpvt-1 ) = work( ipn+jj-1 )
                  work( ipn+nq+jjpvt-1 ) = work( ipn+nq+jj-1 )
               END IF
            ELSE
               IF( mycol.EQ.icurcol ) THEN
*
                  CALL dgesd2d( ictxt, mp, 1, a( iia+(jj-1)*lda ), lda,
     $                          myrow, ipcol )
                  work( ipw )   = dble( ipiv( jj ) )
                  work( ipw+1 ) = work( ipn + jj - 1 )
                  work( ipw+2 ) = work( ipn + nq + jj - 1 )
                  CALL dgesd2d( ictxt, 3, 1, work( ipw ), 3, myrow,
     $                          ipcol )
*
                  CALL dgerv2d( ictxt, mp, 1, a( iia+(jj-1)*lda ), lda,
     $                          myrow, ipcol )
                  CALL igerv2d( ictxt, 1, 1, ipiv( jj ), 1, myrow,
     $                          ipcol )
*
               ELSE IF( mycol.EQ.ipcol ) THEN
*
                  CALL dgesd2d( ictxt, mp, 1, a( iia+(jjpvt-1)*lda ),
     $                          lda, myrow, icurcol )
                  CALL igesd2d( ictxt, 1, 1, ipiv( jjpvt ), 1, myrow,
     $                          icurcol )
*
                  CALL dgerv2d( ictxt, mp, 1, a( iia+(jjpvt-1)*lda ),
     $                          lda, myrow, icurcol )
                  CALL dgerv2d( ictxt, 3, 1, work( ipw ), 3, myrow,
     $                          icurcol )
                  ipiv( jjpvt ) = idint( work( ipw ) )
                  work( ipn+jjpvt-1 ) = work( ipw+1 )
                  work( ipn+nq+jjpvt-1 ) = work( ipw+2 )
*
               END IF
*
            END IF
*
         END IF
*
*        Generate elementary reflector H(i)
*
         CALL infog1l( i, desca( mb_ ), nprow, myrow, desca( rsrc_ ),
     $                 ii, icurrow )
         IF( desca( m_ ).EQ.1 ) THEN
            IF( myrow.EQ.icurrow ) THEN
               IF( mycol.EQ.icurcol ) THEN
                  ioffa = ii+(jj-1)*desca( lld_ )
                  ajj = a( ioffa )
                  CALL dlarfg( 1, ajj, a( ioffa ), 1, tau( jj ) )
                  IF( n.GT.1 ) THEN
                     alpha = one - tau( jj )
                     CALL dgebs2d( ictxt, 'Rowwise', ' ', 1, 1, alpha,
     $                                  1 )
                     CALL dscal( nq-jj, alpha, a( ioffa+desca( lld_ ) ),
     $                           desca( lld_ ) )
                  END IF
                  CALL dgebs2d( ictxt, 'Columnwise', ' ', 1, 1,
     $                          tau( jj ), 1 )
                  a( ioffa ) = ajj
               ELSE
                  IF( n.GT.1 ) THEN
                     CALL dgebr2d( ictxt, 'Rowwise', ' ', 1, 1, alpha,
     $                             1, icurrow, icurcol )
                     CALL dscal( nq-jj+1, alpha, a( i ), desca( lld_ ) )
                  END IF
               END IF
            ELSE IF( mycol.EQ.icurcol ) THEN
               CALL dgebr2d( ictxt, 'Columnwise', ' ', 1, 1, tau( jj ),
     $                       1, icurrow, icurcol )
            END IF
*
         ELSE
*
            CALL pdlarfg( m-j+ja, ajj, i, j, a, min( i+1, ia+m-1 ), j,
     $                    desca, 1, tau )
            IF( j.LT.ja+n-1 ) THEN
*
*              Apply H(i) to A(ia+j-ja:ia+m-1,j+1:ja+n-1) from the left
*
               CALL pdelset( a, i, j, desca, one )
               CALL pdlarf( 'Left', m-j+ja, ja+n-1-j, a, i, j, desca,
     $                      1, tau, a, i, j+1, desca, work( ipw ) )
            END IF
            CALL pdelset( a, i, j, desca, ajj )
*
         END IF
*
*        Update partial columns norms
*
         IF( mycol.EQ.icurcol )
     $      jj = jj + 1
         IF( mod( j, desca( nb_ ) ).EQ.0 )
     $      icurcol = mod( icurcol+1, npcol )
         IF( (jja+nq-jj).GT.0 ) THEN
            IF( myrow.EQ.icurrow ) THEN
               CALL dgebs2d( ictxt, 'Columnwise', ' ', 1, jja+nq-jj,
     $                       a( ii+( min( jja+nq-1, jj )-1 )*lda ),
     $                       lda )
               CALL dcopy( jja+nq-jj, a( ii+( min( jja+nq-1, jj )
     $                     -1)*lda ), lda, work( ipw+min( jja+nq-1,
     $                    jj )-1 ), 1 )
            ELSE
               CALL dgebr2d( ictxt, 'Columnwise', ' ', jja+nq-jj, 1,
     $                       work( ipw+min( jja+nq-1, jj )-1 ),
     $                       max( 1, nq ), icurrow, mycol )
            END IF
         END IF
*
         jn = min( iceil( j+1, desca( nb_ ) ) * desca( nb_ ),
     $                    ja + n - 1 )
         IF( mycol.EQ.icurcol ) THEN
            DO 90 ll = jj-1, jj + jn - j - 2
               IF( work( ipn+ll ).NE.zero ) THEN
                  temp = abs( work( ipw+ll ) ) / work( ipn+ll )
                  temp = max( zero, ( one+temp )*( one-temp ) )
                  temp2 = temp*( work( ipn+ll ) / work( ipn+nq+ll ) )**2
                  IF( temp2.LE.tol3z ) THEN
                     IF( ia+m-1.GT.i ) THEN
                        CALL pdnrm2( ia+m-i-1, work( ipn+ll ), a, i+1,
     $                               j+ll-jj+2, desca, 1 )
                        work( ipn+nq+ll ) = work( ipn+ll )
                     ELSE
                        work( ipn+ll ) = zero
                        work( ipn+nq+ll ) = zero
                     END IF
                  ELSE
                     work( ipn+ll ) = work( ipn+ll ) * sqrt( temp )
                  END IF
               END IF
   90       CONTINUE
            jj = jj + jn - j
         END IF
         icurcol = mod( icurcol+1, npcol )
*
         DO 110 k = jn+1, ja+n-1, desca( nb_ )
            kb = min( ja+n-k, desca( nb_ ) )
*
            IF( mycol.EQ.icurcol ) THEN
               DO 100 ll = jj-1, jj+kb-2
                  IF( work( ipn+ll ).NE.zero ) THEN
                     temp = abs( work( ipw+ll ) ) / work( ipn+ll )
                     temp = max( zero, ( one+temp )*( one-temp ) )
                     temp2 = temp*
     $                         ( work( ipn+ll ) / work( ipn+nq+ll ) )**2
                     IF( temp2.LE.tol3z ) THEN
                        IF( ia+m-1.GT.i ) THEN
                           CALL pdnrm2( ia+m-i-1, work( ipn+ll ), a,
     $                                  i+1, k+ll-jj+1, desca, 1 )
                           work( ipn+nq+ll ) = work( ipn+ll )
                        ELSE
                           work( ipn+ll ) = zero
                           work( ipn+nq+ll ) = zero
                        END IF
                     ELSE
                        work( ipn+ll ) = work( ipn+ll ) * sqrt( temp )
                     END IF
                  END IF
  100          CONTINUE
               jj = jj + kb
            END IF
            icurcol = mod( icurcol+1, npcol )
*
  110    CONTINUE
*
  120 CONTINUE
*
      work( 1 ) = dble( lwmin )
*
      RETURN
*
*     End of PDGEQPF
*

Here is the call graph for this function:

Here is the caller graph for this function: