pdlaset()

subroutine pdlaset	(	character*1	uplo,
		integer	m,
		integer	n,
		double precision	alpha,
		double precision	beta,
		double precision, dimension( * )	a,
		integer	ia,
		integer	ja,
		integer, dimension( * )	desca
	)

Definition at line 6861 of file pdblastst.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 ..
      CHARACTER*1        UPLO
      INTEGER            IA, JA, M, N
      DOUBLE PRECISION   ALPHA, BETA
*     ..
*     .. Array Arguments ..
      INTEGER            DESCA( * )
      DOUBLE PRECISION   A( * )
*     ..
*
*  Purpose
*  =======
*
*  PDLASET  initializes an m by n submatrix A(IA:IA+M-1,JA:JA+N-1) deno-
*  ted  by  sub( A )  to beta on the diagonal and alpha on the offdiago-
*  nals.
*
*  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
*  =========
*
*  UPLO    (global input) CHARACTER*1
*          On entry, UPLO specifies the part  of  the submatrix sub( A )
*          to be set:
*             = 'L' or 'l':   Lower triangular part is set; the strictly
*                      upper triangular part of sub( A ) is not changed;
*             = 'U' or 'u':   Upper triangular part is set; the strictly
*                      lower triangular part of sub( A ) is not changed;
*             Otherwise:  All of the matrix sub( A ) is set.
*
*  M       (global input) INTEGER
*          On entry,  M  specifies the number of rows of  the  submatrix
*          sub( A ). M  must be at least zero.
*
*  N       (global input) INTEGER
*          On entry, N  specifies the number of columns of the submatrix
*          sub( A ). N must be at least zero.
*
*  ALPHA   (global input) DOUBLE PRECISION
*          On entry,  ALPHA  specifies the scalar alpha, i.e., the cons-
*          tant to which the offdiagonal elements are to be set.
*
*  BETA    (global input) DOUBLE PRECISION
*          On entry, BETA  specifies the scalar beta, i.e., the constant
*          to which the diagonal elements are to be set.
*
*  A       (local input/local output) DOUBLE PRECISION 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  to be  set.  On exit, the
*          leading m by n submatrix sub( A ) is set as follows:
*
*          if UPLO = 'U',  A(IA+i-1,JA+j-1) = ALPHA, 1<=i<=j-1, 1<=j<=N,
*          if UPLO = 'L',  A(IA+i-1,JA+j-1) = ALPHA, j+1<=i<=M, 1<=j<=N,
*          otherwise,      A(IA+i-1,JA+j-1) = ALPHA, 1<=i<=M,   1<=j<=N,
*                                                      and IA+i.NE.JA+j,
*          and, for all UPLO,  A(IA+i-1,JA+i-1) = BETA,  1<=i<=min(M,N).
*
*  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, ISCOLREP, ISROWREP, LOWER,
     $                   UPPER
      INTEGER            IACOL, IAROW, ICTXT, IIA, IIMAX, ILOW, IMB1,
     $                   IMBLOC, INB1, INBLOC, IOFFA, IOFFD, IUPP, JJA,
     $                   JJMAX, JOFFA, JOFFD, LCMT, LCMT00, LDA, LMBLOC,
     $                   LNBLOC, LOW, M1, MB, MBLKD, MBLKS, MBLOC, MP,
     $                   MRCOL, MRROW, MYCOL, MYROW, N1, NB, NBLKD,
     $                   NBLKS, NBLOC, NPCOL, NPROW, NQ, PMB, QNB, TMP1,
     $                   UPP
*     ..
*     .. Local Arrays ..
      INTEGER            DESCA2( DLEN_ )
*     ..
*     .. External Subroutines ..
      EXTERNAL           blacs_gridinfo, pb_ainfog2l, pb_binfo,
     $                   pb_desctrans, pb_dlaset
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      EXTERNAL           lsame
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          min
*     ..
*     .. Executable Statements ..
*
      IF( m.EQ.0 .OR. n.EQ.0 )
     $   RETURN
*
*     Convert descriptor
*
      CALL pb_desctrans( desca, desca2 )
*
*     Get grid parameters
*
      ictxt = desca2( ctxt_ )
      CALL blacs_gridinfo( ictxt, nprow, npcol, myrow, mycol )
*
      CALL pb_ainfog2l( m, n, ia, ja, desca2, nprow, npcol, myrow,
     $                  mycol, imb1, inb1, mp, nq, iia, jja, iarow,
     $                  iacol, mrrow, mrcol )
*
      IF( mp.LE.0 .OR. nq.LE.0 )
     $   RETURN
*
      isrowrep = ( desca2( rsrc_ ).LT.0 )
      iscolrep = ( desca2( csrc_ ).LT.0 )
      lda      = desca2( lld_ )
*
      upper = .NOT.( lsame( uplo, 'L' ) )
      lower = .NOT.( lsame( uplo, 'U' ) )
*
      IF( ( ( lower.AND.upper ).AND.( alpha.EQ.beta ) ).OR.
     $    (   isrowrep        .AND.  iscolrep        ) ) THEN
         IF( ( mp.GT.0 ).AND.( nq.GT.0 ) )
     $      CALL pb_dlaset( uplo, mp, nq, 0, alpha, beta,
     $                      a( iia + ( jja - 1 ) * lda ), lda )
         RETURN
      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, mp, nq, imb1, inb1, mb, nb, mrrow, mrcol,
     $               lcmt00, mblks, nblks, imbloc, inbloc, lmbloc,
     $               lnbloc, ilow, low, iupp, upp )
*
      ioffa = iia - 1
      joffa = jja - 1
      iimax = ioffa + mp
      jjmax = joffa + nq
*
      IF( isrowrep ) THEN
         pmb = mb
      ELSE
         pmb = nprow * mb
      END IF
      IF( iscolrep ) THEN
         qnb = nb
      ELSE
         qnb = npcol * nb
      END IF
*
      m1 = mp
      n1 = nq
*
*     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
*
         goleft = ( ( lcmt00 - ( iupp - upp + pmb ) ).LT.ilow )
         godown = .NOT.goleft
*
         CALL pb_dlaset( uplo, imbloc, inbloc, lcmt00, alpha, beta,
     $                   a( iia+joffa*lda ), lda )
         IF( godown ) THEN
            IF( upper .AND. nq.GT.inbloc )
     $         CALL pb_dlaset( 'All', imbloc, nq-inbloc, 0, alpha,
     $                         alpha, a( iia+(joffa+inbloc)*lda ), lda )
            iia = iia + imbloc
            m1  = m1 - imbloc
         ELSE
            IF( lower .AND. mp.GT.imbloc )
     $         CALL pb_dlaset( 'All', mp-imbloc, inbloc, 0, alpha,
     $                         alpha, a( iia+imbloc+joffa*lda ), lda )
            jja = jja + inbloc
            n1  = n1 - inbloc
         END IF
*
      END IF
*
      IF( godown ) THEN
*
         lcmt00 = lcmt00 - ( iupp - upp + pmb )
         mblks  = mblks - 1
         ioffa  = ioffa + imbloc
*
   10    CONTINUE
         IF( mblks.GT.0 .AND. lcmt00.GT.upp ) THEN
            lcmt00 = lcmt00 - pmb
            mblks  = mblks - 1
            ioffa  = ioffa + mb
            GO TO 10
         END IF
*
         tmp1 = min( ioffa, iimax ) - iia + 1
         IF( upper .AND. tmp1.GT.0 ) THEN
            CALL pb_dlaset( 'All', tmp1, n1, 0, alpha, alpha,
     $                      a( iia+joffa*lda ), lda )
            iia = iia + tmp1
            m1  = m1 - tmp1
         END IF
*
         IF( mblks.LE.0 )
     $      RETURN
*
         lcmt  = lcmt00
         mblkd = mblks
         ioffd = ioffa
*
         mbloc = mb
   20    CONTINUE
         IF( mblkd.GT.0 .AND. lcmt.GE.ilow ) THEN
            IF( mblkd.EQ.1 )
     $         mbloc = lmbloc
            CALL pb_dlaset( uplo, mbloc, inbloc, lcmt, alpha, beta,
     $                      a( ioffd+1+joffa*lda ), lda )
            lcmt00 = lcmt
            lcmt   = lcmt - pmb
            mblks  = mblkd
            mblkd  = mblkd - 1
            ioffa  = ioffd
            ioffd  = ioffd + mbloc
            GO TO 20
         END IF
*
         tmp1 = m1 - ioffd + iia - 1
         IF( lower .AND. tmp1.GT.0 )
     $      CALL pb_dlaset( 'ALL', tmp1, inbloc, 0, alpha, alpha,
     $                      a( ioffd+1+joffa*lda ), lda )
*
         tmp1   = ioffa - iia + 1
         m1     = m1 - tmp1
         n1     = n1 - inbloc
         lcmt00 = lcmt00 + low - ilow + qnb
         nblks  = nblks - 1
         joffa  = joffa + inbloc
*
         IF( upper .AND. tmp1.GT.0 .AND. n1.GT.0 )
     $      CALL pb_dlaset( 'ALL', tmp1, n1, 0, alpha, alpha,
     $                      a( iia+joffa*lda ), lda )
*
         iia = ioffa + 1
         jja = joffa + 1
*
      ELSE IF( goleft ) THEN
*
         lcmt00 = lcmt00 + low - ilow + qnb
         nblks  = nblks - 1
         joffa  = joffa + inbloc
*
   30    CONTINUE
         IF( nblks.GT.0 .AND. lcmt00.LT.low ) THEN
            lcmt00 = lcmt00 + qnb
            nblks  = nblks - 1
            joffa  = joffa + nb
            GO TO 30
         END IF
*
         tmp1 = min( joffa, jjmax ) - jja + 1
         IF( lower .AND. tmp1.GT.0 ) THEN
            CALL pb_dlaset( 'All', m1, tmp1, 0, alpha, alpha,
     $                      a( iia+(jja-1)*lda ), lda )
            jja = jja + tmp1
            n1  = n1 - tmp1
         END IF
*
         IF( nblks.LE.0 )
     $      RETURN
*
         lcmt  = lcmt00
         nblkd = nblks
         joffd = joffa
*
         nbloc = nb
   40    CONTINUE
         IF( nblkd.GT.0 .AND. lcmt.LE.iupp ) THEN
            IF( nblkd.EQ.1 )
     $         nbloc = lnbloc
            CALL pb_dlaset( uplo, imbloc, nbloc, lcmt, alpha, beta,
     $                      a( iia+joffd*lda ), lda )
            lcmt00 = lcmt
            lcmt   = lcmt + qnb
            nblks  = nblkd
            nblkd  = nblkd - 1
            joffa  = joffd
            joffd  = joffd + nbloc
            GO TO 40
         END IF
*
         tmp1 = n1 - joffd + jja - 1
         IF( upper .AND. tmp1.GT.0 )
     $      CALL pb_dlaset( 'All', imbloc, tmp1, 0, alpha, alpha,
     $                      a( iia+joffd*lda ), lda )
*
         tmp1   = joffa - jja + 1
         m1     = m1 - imbloc
         n1     = n1 - tmp1
         lcmt00 = lcmt00 - ( iupp - upp + pmb )
         mblks  = mblks - 1
         ioffa  = ioffa + imbloc
*
         IF( lower .AND. m1.GT.0 .AND. tmp1.GT.0 )
     $      CALL pb_dlaset( 'All', m1, tmp1, 0, alpha, alpha,
     $                      a( ioffa+1+(jja-1)*lda ), lda )
*
         iia = ioffa + 1
         jja = joffa + 1
*
      END IF
*
      nbloc = nb
   50 CONTINUE
      IF( nblks.GT.0 ) THEN
         IF( nblks.EQ.1 )
     $      nbloc = lnbloc
   60    CONTINUE
         IF( mblks.GT.0 .AND. lcmt00.GT.upp ) THEN
            lcmt00 = lcmt00 - pmb
            mblks  = mblks - 1
            ioffa  = ioffa + mb
            GO TO 60
         END IF
*
         tmp1 = min( ioffa, iimax ) - iia + 1
         IF( upper .AND. tmp1.GT.0 ) THEN
            CALL pb_dlaset( 'All', tmp1, n1, 0, alpha, alpha,
     $                      a( iia+joffa*lda ), lda )
            iia = iia + tmp1
            m1  = m1 - tmp1
         END IF
*
         IF( mblks.LE.0 )
     $      RETURN
*
         lcmt  = lcmt00
         mblkd = mblks
         ioffd = ioffa
*
         mbloc = mb
   70    CONTINUE
         IF( mblkd.GT.0 .AND. lcmt.GE.low ) THEN
            IF( mblkd.EQ.1 )
     $         mbloc = lmbloc
            CALL pb_dlaset( uplo, mbloc, nbloc, lcmt, alpha, beta,
     $                      a( ioffd+1+joffa*lda ), lda )
            lcmt00 = lcmt
            lcmt   = lcmt - pmb
            mblks  = mblkd
            mblkd  = mblkd - 1
            ioffa  = ioffd
            ioffd  = ioffd + mbloc
            GO TO 70
         END IF
*
         tmp1 = m1 - ioffd + iia - 1
         IF( lower .AND. tmp1.GT.0 )
     $      CALL pb_dlaset( 'All', tmp1, nbloc, 0, alpha, alpha,
     $                      a( ioffd+1+joffa*lda ), lda )
*
         tmp1   = min( ioffa, iimax )  - iia + 1
         m1     = m1 - tmp1
         n1     = n1 - nbloc
         lcmt00 = lcmt00 + qnb
         nblks  = nblks - 1
         joffa  = joffa + nbloc
*
         IF( upper .AND. tmp1.GT.0 .AND. n1.GT.0 )
     $      CALL pb_dlaset( 'All', tmp1, n1, 0, alpha, alpha,
     $                      a( iia+joffa*lda ), lda )
*
         iia = ioffa + 1
         jja = joffa + 1
*
         GO TO 50
*
      END IF
*
      RETURN
*
*     End of PDLASET
*

Here is the call graph for this function:

Here is the caller graph for this function: