pslascal()

subroutine pslascal	(	character*1	type,
		integer	m,
		integer	n,
		real	alpha,
		real, dimension( * )	a,
		integer	ia,
		integer	ja,
		integer, dimension( * )	desca
	)

Definition at line 1 of file psblastim.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        TYPE
      INTEGER            IA, JA, M, N
      REAL               ALPHA
*     ..
*     .. Array Arguments ..
      INTEGER            DESCA( * )
      REAL               A( * )
*     ..
*
*  Purpose
*  =======
*
*  PSLASCAL  scales the  m by n submatrix A(IA:IA+M-1,JA:JA+N-1) denoted
*  by sub( A ) by the scalar alpha. TYPE  specifies if sub( A ) is full,
*  upper triangular, lower triangular or upper Hessenberg.
*
*  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
*  =========
*
*  TYPE    (global input) CHARACTER*1
*          On entry,  TYPE  specifies the type of the input submatrix as
*          follows:
*             = 'L' or 'l':  sub( A ) is a lower triangular matrix,
*             = 'U' or 'u':  sub( A ) is an upper triangular matrix,
*             = 'H' or 'h':  sub( A ) is an upper Hessenberg matrix,
*             otherwise sub( A ) is a  full matrix.
*
*  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) REAL
*          On entry, ALPHA specifies the scalar alpha.
*
*  A       (local input/local output) REAL 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
*          to  the entries of the submatrix sub( A ) are  overwritten by
*          the local entries of the m by n scaled submatrix.
*
*  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 ..
      CHARACTER*1        UPLO
      LOGICAL            GODOWN, GOLEFT, LOWER, UPPER
      INTEGER            IACOL, IAROW, ICTXT, IIA, IIMAX, ILOW, IMB1,
     $                   IMBLOC, INB1, INBLOC, IOFFA, IOFFD, ITYPE,
     $                   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_infog2l, pb_slascal
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      INTEGER            PB_NUMROC
      EXTERNAL           lsame, pb_numroc
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          min
*     ..
*     .. Executable Statements ..
*
*     Convert descriptor
*
      CALL pb_desctrans( desca, desca2 )
*
*     Get grid parameters
*
      ictxt = desca2( ctxt_ )
      CALL blacs_gridinfo( ictxt, nprow, npcol, myrow, mycol )
*
*     Quick return if possible
*
      IF( m.EQ.0 .OR. n.EQ.0 )
     $   RETURN
*
      IF( lsame( TYPE, 'L' ) ) THEN
         itype = 1
         uplo  = TYPE
         upper = .false.
         lower = .true.
         ioffd = 0
      ELSE IF( lsame( TYPE, 'U' ) ) THEN
         itype = 2
         uplo  = TYPE
         upper = .true.
         lower = .false.
         ioffd = 0
      ELSE IF( lsame( TYPE, 'H' ) ) THEN
         itype = 3
         uplo  = 'U'
         upper = .true.
         lower = .false.
         ioffd = 1
      ELSE
         itype = 0
         uplo  = 'A'
         upper = .true.
         lower = .true.
         ioffd = 0
      END IF
*
*     Compute local indexes
*
      IF( itype.EQ.0 ) THEN
*
*        Full matrix
*
         CALL pb_infog2l( ia, ja, desca2, nprow, npcol, myrow, mycol,
     $                    iia, jja, iarow, iacol )
         mp = pb_numroc( m, ia, desca2( imb_ ), desca2( mb_ ), myrow,
     $                   desca2( rsrc_ ), nprow )
         nq = pb_numroc( n, ja, desca2( inb_ ), desca2( nb_ ), mycol,
     $                   desca2( csrc_ ), npcol )
*
         IF( mp.LE.0 .OR. nq.LE.0 )
     $      RETURN
*
         lda   = desca2( lld_ )
         ioffa = iia + ( jja - 1 ) * lda
*
         CALL pb_slascal( 'All', mp, nq, 0, alpha, a( ioffa ), lda )
*
      ELSE
*
*        Trapezoidal matrix
*
         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
*
*        Initialize LCMT00, MBLKS, NBLKS, IMBLOC, INBLOC, LMBLOC,
*        LNBLOC, ILOW, LOW, IUPP, and UPP.
*
         mb  = desca2( mb_ )
         nb  = desca2( nb_ )
         lda = desca2( lld_ )
*
         CALL pb_binfo( ioffd, mp, nq, imb1, inb1, mb, nb, mrrow,
     $                  mrcol, lcmt00, mblks, nblks, imbloc, inbloc,
     $                  lmbloc, lnbloc, ilow, low, iupp, upp )
*
         m1    = mp
         n1    = nq
         ioffa = iia - 1
         joffa = jja - 1
         iimax = ioffa + mp
         jjmax = joffa + nq
*
         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
*
            goleft = ( ( lcmt00 - ( iupp - upp + pmb ) ).LT.ilow )
            godown = .NOT.goleft
*
            CALL pb_slascal( uplo, imbloc, inbloc, lcmt00, alpha,
     $                       a( iia+joffa*lda ), lda )
            IF( godown ) THEN
               IF( upper .AND. nq.GT.inbloc )
     $            CALL pb_slascal( 'All', imbloc, nq-inbloc, 0, alpha,
     $                             a( iia+(joffa+inbloc)*lda ), lda )
               iia = iia + imbloc
               m1  = m1 - imbloc
            ELSE
               IF( lower .AND. mp.GT.imbloc )
     $            CALL pb_slascal( 'All', mp-imbloc, inbloc, 0, 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_slascal( 'All', tmp1, n1, 0, 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_slascal( uplo, mbloc, inbloc, lcmt, alpha,
     $                          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_slascal( 'All', tmp1, inbloc, 0, 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_slascal( 'All', tmp1, n1, 0, 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_slascal( 'All', m1, tmp1, 0, 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_slascal( uplo, imbloc, nbloc, lcmt, alpha,
     $                          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_slascal( 'All', imbloc, tmp1, 0, 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_slascal( 'All', m1, tmp1, 0, 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_slascal( 'All', tmp1, n1, 0, 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_slascal( uplo, mbloc, nbloc, lcmt, alpha,
     $                          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_slascal( 'All', tmp1, nbloc, 0, 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_slascal( 'All', tmp1, n1, 0, alpha,
     $                          a( iia+joffa*lda ), lda )
*
            iia = ioffa + 1
            jja = joffa + 1
*
            GO TO 50
*
         END IF
*
      END IF
*
      RETURN
*
*     End of PSLASCAL
*

Here is the call graph for this function: