pzladom()

subroutine pzladom	(	logical	inplace,
		integer	n,
		complex*16	alpha,
		complex*16, dimension( * )	a,
		integer	ia,
		integer	ja,
		integer, dimension( * )	desca
	)

Definition at line 8895 of file pzblastst.f.

*
*  -- PBLAS test routine (version 2.0) --
*     University of Tennessee, Knoxville, Oak Ridge National Laboratory,
*     and University of California, Berkeley.
*     April 1, 1998
*
*     .. Scalar Arguments ..
      LOGICAL            INPLACE
      INTEGER            IA, JA, N
      COMPLEX*16         ALPHA
*     ..
*     .. Array Arguments ..
      INTEGER            DESCA( * )
      COMPLEX*16         A( * )
*     ..
*
*  Purpose
*  =======
*
*  PZLADOM  adds alpha to the diagonal entries  of  an  n by n submatrix
*  sub( A ) denoting A( IA:IA+N-1, JA:JA+N-1 ).
*
*  Notes
*  =====
*
*  A description  vector  is associated with each 2D block-cyclicly dis-
*  tributed matrix.  This  vector  stores  the  information  required to
*  establish the  mapping  between a  matrix entry and its corresponding
*  process and memory location.
*
*  In  the  following  comments,   the character _  should  be  read  as
*  "of  the  distributed  matrix".  Let  A  be a generic term for any 2D
*  block cyclicly distributed matrix.  Its description vector is DESCA:
*
*  NOTATION         STORED IN       EXPLANATION
*  ---------------- --------------- ------------------------------------
*  DTYPE_A (global) DESCA( DTYPE_ ) The descriptor type.
*  CTXT_A  (global) DESCA( CTXT_  ) The BLACS context handle, indicating
*                                   the NPROW x NPCOL BLACS process grid
*                                   A  is distributed over.  The context
*                                   itself  is  global,  but  the handle
*                                   (the integer value) may vary.
*  M_A     (global) DESCA( M_     ) The  number of rows in the distribu-
*                                   ted matrix A, M_A >= 0.
*  N_A     (global) DESCA( N_     ) The number of columns in the distri-
*                                   buted matrix A, N_A >= 0.
*  IMB_A   (global) DESCA( IMB_   ) The number of rows of the upper left
*                                   block of the matrix A, IMB_A > 0.
*  INB_A   (global) DESCA( INB_   ) The  number  of columns of the upper
*                                   left   block   of   the   matrix  A,
*                                   INB_A > 0.
*  MB_A    (global) DESCA( MB_    ) The blocking factor used to  distri-
*                                   bute the last  M_A-IMB_A rows of  A,
*                                   MB_A > 0.
*  NB_A    (global) DESCA( NB_    ) The blocking factor used to  distri-
*                                   bute the last  N_A-INB_A  columns of
*                                   A, NB_A > 0.
*  RSRC_A  (global) DESCA( RSRC_  ) The process row over which the first
*                                   row of the matrix  A is distributed,
*                                   NPROW > RSRC_A >= 0.
*  CSRC_A  (global) DESCA( CSRC_  ) The  process  column  over which the
*                                   first  column of  A  is distributed.
*                                   NPCOL > CSRC_A >= 0.
*  LLD_A   (local)  DESCA( LLD_   ) The  leading  dimension of the local
*                                   array  storing  the  local blocks of
*                                   the distributed matrix A,
*                                   IF( Lc( 1, N_A ) > 0 )
*                                      LLD_A >= MAX( 1, Lr( 1, M_A ) )
*                                   ELSE
*                                      LLD_A >= 1.
*
*  Let K be the number of  rows of a matrix A starting at the global in-
*  dex IA,i.e, A( IA:IA+K-1, : ). Lr( IA, K ) denotes the number of rows
*  that the process of row coordinate MYROW ( 0 <= MYROW < NPROW ) would
*  receive if these K rows were distributed over NPROW processes.  If  K
*  is the number of columns of a matrix  A  starting at the global index
*  JA, i.e, A( :, JA:JA+K-1, : ), Lc( JA, K ) denotes the number  of co-
*  lumns that the process MYCOL ( 0 <= MYCOL < NPCOL ) would  receive if
*  these K columns were distributed over NPCOL processes.
*
*  The values of Lr() and Lc() may be determined via a call to the func-
*  tion PB_NUMROC:
*  Lr( IA, K ) = PB_NUMROC( K, IA, IMB_A, MB_A, MYROW, RSRC_A, NPROW )
*  Lc( JA, K ) = PB_NUMROC( K, JA, INB_A, NB_A, MYCOL, CSRC_A, NPCOL )
*
*  Arguments
*  =========
*
*  INPLACE (global input) LOGICAL
*          On entry, INPLACE specifies if the matrix should be generated
*          in place or not. If INPLACE is .TRUE., the local random array
*          to be generated  will start in memory at the local memory lo-
*          cation A( 1, 1 ),  otherwise it will start at the local posi-
*          tion induced by IA and JA.
*
*  N       (global input) INTEGER
*          On entry,  N  specifies  the  global  order  of the submatrix
*          sub( A ) to be modified. N must be at least zero.
*
*  ALPHA   (global input) COMPLEX*16
*          On entry, ALPHA specifies the scalar alpha.
*
*  A       (local input/local output) COMPLEX*16 array
*          On entry, A is an array of dimension (LLD_A, Ka), where Ka is
*          at least Lc( 1, JA+N-1 ).  Before  entry, this array contains
*          the local entries of the matrix A. On exit, the local entries
*          of this array corresponding to the main diagonal of  sub( A )
*          have been updated.
*
*  IA      (global input) INTEGER
*          On entry, IA  specifies A's global row index, which points to
*          the beginning of the submatrix sub( A ).
*
*  JA      (global input) INTEGER
*          On entry, JA  specifies A's global column index, which points
*          to the beginning of the submatrix sub( A ).
*
*  DESCA   (global and local input) INTEGER array
*          On entry, DESCA  is an integer array of dimension DLEN_. This
*          is the array descriptor for the matrix A.
*
*  -- Written on April 1, 1998 by
*     Antoine Petitet, University  of  Tennessee, Knoxville 37996, USA.
*
*  =====================================================================
*
*     .. Parameters ..
      INTEGER            BLOCK_CYCLIC_2D_INB, CSRC_, CTXT_, DLEN_,
     $                   DTYPE_, IMB_, INB_, LLD_, MB_, M_, NB_, N_,
     $                   RSRC_
      parameter( block_cyclic_2d_inb = 2, dlen_ = 11,
     $                   dtype_ = 1, ctxt_ = 2, m_ = 3, n_ = 4,
     $                   imb_ = 5, inb_ = 6, mb_ = 7, nb_ = 8,
     $                   rsrc_ = 9, csrc_ = 10, lld_ = 11 )
*     ..
*     .. Local Scalars ..
      LOGICAL            GODOWN, GOLEFT
      INTEGER            I, IACOL, IAROW, ICTXT, IIA, IJOFFA, ILOW,
     $                   IMB1, IMBLOC, INB1, INBLOC, IOFFA, IOFFD, IUPP,
     $                   JJA, JOFFA, JOFFD, LCMT, LCMT00, LDA, LDAP1,
     $                   LMBLOC, LNBLOC, LOW, MB, MBLKD, MBLKS, MBLOC,
     $                   MRCOL, MRROW, MYCOL, MYROW, NB, NBLKD, NBLKS,
     $                   NBLOC, NP, NPCOL, NPROW, NQ, PMB, QNB, UPP
      COMPLEX*16         ATMP
*     ..
*     .. Local Scalars ..
      INTEGER            DESCA2( DLEN_ )
*     ..
*     .. External Subroutines ..
      EXTERNAL           blacs_gridinfo, pb_ainfog2l, pb_binfo,
     $                   pb_desctrans
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, dble, dcmplx, dimag, max, min
*     ..
*     .. Executable Statements ..
*
*     Convert descriptor
*
      CALL pb_desctrans( desca, desca2 )
*
*     Get grid parameters
*
      ictxt = desca2( ctxt_ )
      CALL blacs_gridinfo( ictxt, nprow, npcol, myrow, mycol )
*
      IF( n.EQ.0 )
     $   RETURN
*
      CALL pb_ainfog2l( n, n, ia, ja, desca2, nprow, npcol, myrow,
     $                  mycol, imb1, inb1, np, nq, iia, jja, iarow,
     $                  iacol, mrrow, mrcol )
*
*     Decide where the entries shall be stored in memory
*
      IF( inplace ) THEN
         iia = 1
         jja = 1
      END IF
*
*     Initialize LCMT00, MBLKS, NBLKS, IMBLOC, INBLOC, LMBLOC, LNBLOC,
*     ILOW, LOW, IUPP, and UPP.
*
      mb = desca2( mb_ )
      nb = desca2( nb_ )
*
      CALL pb_binfo( 0, np, nq, imb1, inb1, mb, nb, mrrow, mrcol,
     $               lcmt00, mblks, nblks, imbloc, inbloc, lmbloc,
     $               lnbloc, ilow, low, iupp, upp )
*
      ioffa  = iia - 1
      joffa  = jja - 1
      lda    = desca2( lld_ )
      ldap1  = lda + 1
*
      IF( desca2( rsrc_ ).LT.0 ) THEN
         pmb = mb
      ELSE
         pmb = nprow * mb
      END IF
      IF( desca2( csrc_ ).LT.0 ) THEN
         qnb = nb
      ELSE
         qnb = npcol * nb
      END IF
*
*     Handle the first block of rows or columns separately, and update
*     LCMT00, MBLKS and NBLKS.
*
      godown = ( lcmt00.GT.iupp )
      goleft = ( lcmt00.LT.ilow )
*
      IF( .NOT.godown .AND. .NOT.goleft ) THEN
*
*        LCMT00 >= ILOW && LCMT00 <= IUPP
*
         IF( lcmt00.GE.0 ) THEN
            ijoffa = ioffa+lcmt00 + ( joffa - 1 ) * lda
            DO 10 i = 1, min( inbloc, max( 0, imbloc - lcmt00 ) )
               atmp = a( ijoffa + i*ldap1 )
               a( ijoffa + i*ldap1 ) = alpha +
     $                                 dcmplx( abs( dble(  atmp ) ),
     $                                         abs( dimag( atmp ) ) )
   10       CONTINUE
         ELSE
            ijoffa = ioffa + ( joffa - lcmt00 - 1 ) * lda
            DO 20 i = 1, min( imbloc, max( 0, inbloc + lcmt00 ) )
               atmp = a( ijoffa + i*ldap1 )
               a( ijoffa + i*ldap1 ) = alpha +
     $                                 dcmplx( abs( dble(  atmp ) ),
     $                                         abs( dimag( atmp ) ) )
   20       CONTINUE
         END IF
         goleft = ( ( lcmt00 - ( iupp - upp + pmb ) ).LT.ilow )
         godown = .NOT.goleft
*
      END IF
*
      IF( godown ) THEN
*
         lcmt00 = lcmt00 - ( iupp - upp + pmb )
         mblks  = mblks - 1
         ioffa  = ioffa + imbloc
*
   30    CONTINUE
         IF( mblks.GT.0 .AND. lcmt00.GT.upp ) THEN
            lcmt00 = lcmt00 - pmb
            mblks  = mblks - 1
            ioffa  = ioffa + mb
            GO TO 30
         END IF
*
         lcmt  = lcmt00
         mblkd = mblks
         ioffd = ioffa
*
         mbloc = mb
   40    CONTINUE
         IF( mblkd.GT.0 .AND. lcmt.GE.ilow ) THEN
            IF( mblkd.EQ.1 )
     $         mbloc = lmbloc
            IF( lcmt.GE.0 ) THEN
               ijoffa = ioffd + lcmt + ( joffa - 1 ) * lda
               DO 50 i = 1, min( inbloc, max( 0, mbloc - lcmt ) )
                  atmp = a( ijoffa + i*ldap1 )
                  a( ijoffa + i*ldap1 ) = alpha +
     $                                    dcmplx( abs( dble(  atmp ) ),
     $                                            abs( dimag( atmp ) ) )
   50          CONTINUE
            ELSE
               ijoffa = ioffd + ( joffa - lcmt - 1 ) * lda
               DO 60 i = 1, min( mbloc, max( 0, inbloc + lcmt ) )
                  atmp = a( ijoffa + i*ldap1 )
                  a( ijoffa + i*ldap1 ) = alpha +
     $                                    dcmplx( abs( dble(  atmp ) ),
     $                                            abs( dimag( atmp ) ) )
   60          CONTINUE
            END IF
            lcmt00 = lcmt
            lcmt   = lcmt - pmb
            mblks  = mblkd
            mblkd  = mblkd - 1
            ioffa  = ioffd
            ioffd  = ioffd + mbloc
            GO TO 40
         END IF
*
         lcmt00 = lcmt00 + low - ilow + qnb
         nblks  = nblks - 1
         joffa  = joffa + inbloc
*
      ELSE IF( goleft ) THEN
*
         lcmt00 = lcmt00 + low - ilow + qnb
         nblks  = nblks - 1
         joffa  = joffa + inbloc
*
   70    CONTINUE
         IF( nblks.GT.0 .AND. lcmt00.LT.low ) THEN
            lcmt00 = lcmt00 + qnb
            nblks  = nblks - 1
            joffa  = joffa + nb
            GO TO 70
         END IF
*
         lcmt  = lcmt00
         nblkd = nblks
         joffd = joffa
*
         nbloc = nb
   80    CONTINUE
         IF( nblkd.GT.0 .AND. lcmt.LE.iupp ) THEN
            IF( nblkd.EQ.1 )
     $         nbloc = lnbloc
            IF( lcmt.GE.0 ) THEN
               ijoffa = ioffa + lcmt + ( joffd - 1 ) * lda
               DO 90 i = 1, min( nbloc, max( 0, imbloc - lcmt ) )
                  atmp = a( ijoffa + i*ldap1 )
                  a( ijoffa + i*ldap1 ) = alpha +
     $                                    dcmplx( abs( dble(  atmp ) ),
     $                                            abs( dimag( atmp ) ) )
   90          CONTINUE
            ELSE
               ijoffa = ioffa + ( joffd - lcmt - 1 ) * lda
               DO 100 i = 1, min( imbloc, max( 0, nbloc + lcmt ) )
                  atmp = a( ijoffa + i*ldap1 )
                  a( ijoffa + i*ldap1 ) = alpha +
     $                                    dcmplx( abs( dble(  atmp ) ),
     $                                            abs( dimag( atmp ) ) )
  100          CONTINUE
            END IF
            lcmt00 = lcmt
            lcmt   = lcmt + qnb
            nblks  = nblkd
            nblkd  = nblkd - 1
            joffa  = joffd
            joffd  = joffd + nbloc
            GO TO 80
         END IF
*
         lcmt00 = lcmt00 - ( iupp - upp + pmb )
         mblks  = mblks - 1
         ioffa  = ioffa + imbloc
*
      END IF
*
      nbloc = nb
  110 CONTINUE
      IF( nblks.GT.0 ) THEN
         IF( nblks.EQ.1 )
     $      nbloc = lnbloc
  120    CONTINUE
         IF( mblks.GT.0 .AND. lcmt00.GT.upp ) THEN
            lcmt00 = lcmt00 - pmb
            mblks  = mblks - 1
            ioffa  = ioffa + mb
            GO TO 120
         END IF
*
         lcmt  = lcmt00
         mblkd = mblks
         ioffd = ioffa
*
         mbloc = mb
  130    CONTINUE
         IF( mblkd.GT.0 .AND. lcmt.GE.low ) THEN
            IF( mblkd.EQ.1 )
     $         mbloc = lmbloc
            IF( lcmt.GE.0 ) THEN
               ijoffa = ioffd + lcmt + ( joffa - 1 ) * lda
               DO 140 i = 1, min( nbloc, max( 0, mbloc - lcmt ) )
                  atmp = a( ijoffa + i*ldap1 )
                  a( ijoffa + i*ldap1 ) = alpha +
     $                                    dcmplx( abs( dble(  atmp ) ),
     $                                            abs( dimag( atmp ) ) )
  140          CONTINUE
            ELSE
               ijoffa = ioffd + ( joffa - lcmt - 1 ) * lda
               DO 150 i = 1, min( mbloc, max( 0, nbloc + lcmt ) )
                  atmp = a( ijoffa + i*ldap1 )
                  a( ijoffa + i*ldap1 ) = alpha +
     $                                    dcmplx( abs( dble(  atmp ) ),
     $                                            abs( dimag( atmp ) ) )
  150          CONTINUE
            END IF
            lcmt00 = lcmt
            lcmt   = lcmt - pmb
            mblks  = mblkd
            mblkd  = mblkd - 1
            ioffa  = ioffd
            ioffd  = ioffd + mbloc
            GO TO 130
         END IF
*
         lcmt00 = lcmt00 + qnb
         nblks  = nblks - 1
         joffa  = joffa + nbloc
         GO TO 110
*
      END IF
*
      RETURN
*
*     End of PZLADOM
*

Here is the call graph for this function:

Here is the caller graph for this function: