pb_binfo()

subroutine pb_binfo	(	integer	offd,
		integer	m,
		integer	n,
		integer	imb1,
		integer	inb1,
		integer	mb,
		integer	nb,
		integer	mrrow,
		integer	mrcol,
		integer	lcmt00,
		integer	mblks,
		integer	nblks,
		integer	imbloc,
		integer	inbloc,
		integer	lmbloc,
		integer	lnbloc,
		integer	ilow,
		integer	low,
		integer	iupp,
		integer	upp
	)

Definition at line 3574 of file pblastst.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 ..
      INTEGER            ILOW, IMB1, IMBLOC, INB1, INBLOC, IUPP, LCMT00,
     $                   LMBLOC, LNBLOC, LOW, M, MB, MBLKS, MRCOL,
     $                   MRROW, N, NB, NBLKS, OFFD, UPP
*     ..
*
*  Purpose
*  =======
*
*  PB_BINFO   initializes the local information of an m by n local array
*  owned by the process of  relative  coordinates ( MRROW, MRCOL ). Note
*  that if m or n is less or equal than zero, there is no data, in which
*  case this process  does  not  need  the local information computed by
*  this routine to proceed.
*
*  Arguments
*  =========
*
*  OFFD    (global input) INTEGER
*          On entry,  OFFD  specifies the off-diagonal of the underlying
*          matrix of interest as follows:
*             OFFD = 0 specifies the main diagonal,
*             OFFD > 0 specifies lower subdiagonals, and
*             OFFD < 0 specifies upper superdiagonals.
*
*  M       (local input) INTEGER
*          On entry, M  specifies the local number of rows of the under-
*          lying matrix  owned  by the  process  of relative coordinates
*          ( MRROW, MRCOL ). M must be at least zero.
*
*  N       (local input) INTEGER
*          On entry, N  specifies the local number of columns of the un-
*          derlying matrix  owned by the process of relative coordinates
*          ( MRROW, MRCOL ). N must be at least zero.
*
*  IMB1    (global input) INTEGER
*          On input, IMB1 specifies  the global true size of  the  first
*          block of rows of the underlying global submatrix.  IMB1  must
*          be at least MIN( 1, M ).
*
*  INB1    (global input) INTEGER
*          On input, INB1 specifies  the global true size of  the  first
*          block  of  columns  of  the underlying global submatrix. INB1
*          must be at least MIN( 1, N ).
*
*  MB      (global input) INTEGER
*          On entry, MB  specifies the blocking factor used to partition
*          the rows of the matrix.  MB  must be at least one.
*
*  NB      (global input) INTEGER
*          On entry, NB  specifies the blocking factor used to partition
*          the the columns of the matrix.  NB  must be at least one.
*
*  MRROW   (local input) INTEGER
*          On entry, MRROW specifies the  relative row coordinate of the
*          process that possesses these M rows. MRROW must be least zero
*          and strictly less than NPROW.
*
*  MRCOL   (local input) INTEGER
*          On entry, MRCOL specifies  the  relative column coordinate of
*          the process that possesses these N  columns.  MRCOL  must  be
*          least zero and strictly less than NPCOL.
*
*  LCMT00  (local output) INTEGER
*          On exit, LCMT00  is the  LCM value of the left upper block of
*          this m by n local  block owned by the process of relative co-
*          ordinates ( MRROW, MRCOL ).
*
*  MBLKS   (local output) INTEGER
*          On exit, MBLKS specifies the local number of blocks  of  rows
*          corresponding to M. MBLKS must be at least zero.
*
*  NBLKS   (local output) INTEGER
*          On exit,  NBLKS  specifies  the local number of blocks of co-
*          lumns corresponding to N. NBLKS must be at least zero.
*
*  IMBLOC  (local output) INTEGER
*          On exit, IMBLOC  specifies  the  number of rows (size) of the
*          uppest blocks of this m by n local array owned by the process
*          of relative coordinates ( MRROW, MRCOL ).  IMBLOC is at least
*          MIN( 1, M ).
*
*  INBLOC  (local output) INTEGER
*          On exit, INBLOC  specifies  the  number of columns (size) of
*          the leftmost  blocks of this m by n local array owned by the
*          process of relative coordinates ( MRROW, MRCOL ).  INBLOC is
*          at least MIN( 1, N ).
*
*  LMBLOC  (local output) INTEGER
*          On exit, LMBLOC specifies the number  of  rows  (size) of the
*          lowest blocks of this m by n local array owned by the process
*          of  relative coordinates ( MRROW, MRCOL ). LMBLOC is at least
*          MIN( 1, M ).
*
*  LNBLOC  (local output) INTEGER
*          On exit, LNBLOC specifies the number of columns (size) of the
*          rightmost  blocks of this  m by n  local  array  owned by the
*          process of  relative  coordinates ( MRROW, MRCOL ). LNBLOC is
*          at least MIN( 1, N ).
*
*  ILOW    (local output) INTEGER
*          On exit, ILOW is the lower bound characterizing the first co-
*          lumn block owning offdiagonals of  this  m by n  array.  ILOW
*          must be less or equal than zero.
*
*  LOW     (global output) INTEGER
*          On exit,  LOW  is  the  lower bound characterizing the column
*          blocks with te exception of the  first  one (see ILOW) owning
*          offdiagonals of this m by n array. LOW  must be less or equal
*          than zero.
*
*  IUPP    (local output) INTEGER
*          On exit, IUPP is the upper bound characterizing the first row
*          block owning offdiagonals of this m by n array.  IUPP must be
*          greater or equal than zero.
*
*  UPP     (global output) INTEGER
*          On exit,  UPP  is  the  upper  bound  characterizing  the row
*          blocks with te exception of the  first  one (see IUPP) owning
*          offdiagonals of this m by n array. UPP  must  be  greater  or
*          equal than zero.
*
*  -- Written on April 1, 1998 by
*     Antoine Petitet, University  of  Tennessee, Knoxville 37996, USA.
*
*  =====================================================================
*
*     .. Local Scalars ..
      INTEGER            TMP1
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max, min
*     ..
*     .. Executable Statements ..
*
*     Initialize LOW, ILOW, UPP, IUPP, LMBLOC, LNBLOC, IMBLOC, INBLOC,
*     MBLKS, NBLKS and LCMT00.
*
      low = 1 - nb
      upp = mb - 1
*
      lcmt00 = offd
*
      IF( m.LE.0 .OR. n.LE.0 ) THEN
*
         IF( mrrow.GT.0 ) THEN
            iupp = mb - 1
         ELSE
            iupp = max( 0, imb1 - 1 )
         END IF
         imbloc = 0
         mblks  = 0
         lmbloc = 0
*
         IF( mrcol.GT.0 ) THEN
            ilow = 1 - nb
         ELSE
            ilow = min( 0, 1 - inb1 )
         END IF
         inbloc = 0
         nblks  = 0
         lnbloc = 0
*
         lcmt00 = lcmt00 + ( low - ilow + mrcol * nb ) -
     $            ( iupp - upp + mrrow * mb )
*
         RETURN
*
      END IF
*
      IF( mrrow.GT.0 ) THEN
*
         imbloc = min( m, mb )
         iupp   = mb - 1
         lcmt00 = lcmt00 - ( imb1 - mb + mrrow * mb )
         mblks  = ( m - 1 ) / mb + 1
         lmbloc = m - ( m / mb ) * mb
         IF( lmbloc.EQ.0 )
     $      lmbloc = mb
*
         IF( mrcol.GT.0 ) THEN
*
            inbloc = min( n, nb )
            ilow   = 1 - nb
            lcmt00 = lcmt00 + inb1 - nb + mrcol * nb
            nblks  = ( n - 1 ) / nb + 1
            lnbloc = n - ( n / nb ) * nb
            IF( lnbloc.EQ.0 )
     $         lnbloc = nb
*
         ELSE
*
            inbloc = inb1
            ilow   = 1 - inb1
            tmp1   = n - inb1
            IF( tmp1.GT.0 ) THEN
*
*              more than one block
*
               nblks = ( tmp1 - 1 ) / nb + 2
               lnbloc = tmp1 - ( tmp1 / nb ) * nb
               IF( lnbloc.EQ.0 )
     $            lnbloc = nb
*
            ELSE
*
               nblks  = 1
               lnbloc = inb1
*
            END IF
*
         END IF
*
      ELSE
*
         imbloc = imb1
         iupp = imb1 - 1
         tmp1 = m - imb1
         IF( tmp1.GT.0 ) THEN
*
*           more than one block
*
            mblks  = ( tmp1 - 1 ) / mb + 2
            lmbloc = tmp1 - ( tmp1 / mb ) * mb
            IF( lmbloc.EQ.0 )
     $         lmbloc = mb
*
         ELSE
*
            mblks  = 1
            lmbloc = imb1
*
         END IF
*
         IF( mrcol.GT.0 ) THEN
*
            inbloc = min( n, nb )
            ilow   = 1 - nb
            lcmt00 = lcmt00 + inb1 - nb + mrcol * nb
            nblks  = ( n - 1 ) / nb + 1
            lnbloc = n - ( n / nb ) * nb
            IF( lnbloc.EQ.0 )
     $         lnbloc = nb
*
         ELSE
*
            inbloc = inb1
            ilow   = 1 - inb1
            tmp1   = n - inb1
            IF( tmp1.GT.0 ) THEN
*
*              more than one block
*
               nblks  = ( tmp1 - 1 ) / nb + 2
               lnbloc = tmp1 - ( tmp1 / nb ) * nb
               IF( lnbloc.EQ.0 )
     $            lnbloc = nb
*
            ELSE
*
               nblks  = 1
               lnbloc = inb1
*
            END IF
*
         END IF
*
      END IF
*
      RETURN
*
*     End of PB_BINFO
*

Here is the caller graph for this function: