pzlasizesepr()

subroutine pzlasizesepr	(	integer, dimension( * )	desca,
		integer	iprepad,
		integer	ipostpad,
		integer	sizemqrleft,
		integer	sizemqrright,
		integer	sizeqrf,
		integer	sizetms,
		integer	sizeqtq,
		integer	sizechk,
		integer	sizeheevr,
		integer	rsizeheevr,
		integer	isizeheevr,
		integer	sizesubtst,
		integer	rsizesubtst,
		integer	isizesubtst,
		integer	sizetst,
		integer	rsizetst,
		integer	isizetst
	)

Definition at line 1 of file pzlasizesepr.f.

*
*  -- ScaLAPACK routine (@(MODE)version *TBA*) --
*     University of California, Berkeley and
*     University of Tennessee, Knoxville. 
*     October 21, 2006
*
      IMPLICIT NONE
*
*     .. Scalar Arguments ..
      INTEGER            IPOSTPAD, IPREPAD, ISIZEHEEVR, ISIZESUBTST,
     $                   ISIZETST, RSIZEHEEVR, RSIZESUBTST, RSIZETST,
     $                   SIZECHK, SIZEHEEVR, SIZEMQRLEFT, SIZEMQRRIGHT,
     $                   SIZEQRF, SIZEQTQ, SIZESUBTST, SIZETMS, SIZETST
*     ..
*     .. Array Arguments ..
      INTEGER            DESCA( * )
*
*  Purpose
*  =======
*
*  PZLASIZESEPR computes the amount of memory needed by
*  various SEPR test routines, as well as PZHEEVR itself.
*
*  Arguments
*  =========
*
*  DESCA        (global input) INTEGER array dimension ( DLEN_ )
*               Array descriptor for dense matrix.
*
*  SIZEMQRLEFT  LWORK for the 1st PZUNMQR call in PZLAGHE
*
*  SIZEMQRRIGHT LWORK for the 2nd PZUNMQR call in PZLAGHE
*
*  SIZEQRF      LWORK for PZGEQRF in PZLAGHE
*
*  SIZETMS      LWORK for PZLATMS
*
*  SIZEQTQ      LWORK for PZSEPQTQ
*
*  SIZECHK      LWORK for PZSEPCHK
*
*  SIZEHEEVR    LWORK for PZHEEVR
*
*  RSIZEHEEVR   LRWORK for PZHEEVR
*
*  ISIZEHEEVR   LIWORK for PZHEEVR
*
*  SIZESUBTST   LWORK for PZSEPRSUBTST
*
*  RSIZESUBTST  LRWORK for PZSEPRSUBTST
*
*  ISIZESUBTST  LIWORK for PZSEPRSUBTST
*
*  SIZETST      LWORK for PZSEPRTST
*
*  RSIZETST     LRWORK for PZSEPRTST
*
*  ISIZETST     LIWORK for PZSEPRTST
*
*
*     .. Parameters ..
      INTEGER            CTXT_, M_,
     $                   MB_, NB_, RSRC_, CSRC_, LLD_
      parameter( 
     $                   ctxt_ = 2, m_ = 3, mb_ = 5, nb_ = 6,
     $                   rsrc_ = 7, csrc_ = 8, lld_ = 9 )
*     ..
*     .. Local Scalars ..
      INTEGER            CSRC_A, IACOL, IAROW, ICOFFA, IROFFA, LCM,
     $                   LCMQ, LDA, MQ0, MYCOL, MYROW, N, NB, NEIG, NN,
     $                   NNP, NP, NP0, NPCOL, NPROW, NQ, RSRC_A
      INTEGER            ANB, ICTXT, NHETRD_LWOPT, NPS, SQNPC
*     ..
*     .. External Functions ..
      INTEGER            ICEIL, ILCM, INDXG2P, NUMROC
      EXTERNAL           iceil, ilcm, indxg2p, numroc
      INTEGER            PJLAENV
      EXTERNAL           pjlaenv
*
*     .. External Subroutines ..
      EXTERNAL           blacs_gridinfo
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          dble, int, max, sqrt
*     ..
*     .. Executable Statements ..
*
      n = desca( m_ )
      nb = desca( mb_ )
      rsrc_a = desca( rsrc_ )
      csrc_a = desca( csrc_ )
*
      lda = desca( lld_ )
      CALL blacs_gridinfo( desca( ctxt_ ), nprow, npcol, myrow, mycol )
*
      lcm = ilcm( nprow, npcol )
      lcmq = lcm / npcol
      iroffa = 0
      icoffa = 0
      iarow = indxg2p( 1, nb, myrow, rsrc_a, nprow )
      iacol = indxg2p( 1, nb, mycol, csrc_a, npcol )
      np = numroc( n+iroffa, nb, myrow, iarow, nprow )
      nq = numroc( n+icoffa, nb, mycol, iacol, npcol )
      sizemqrleft = max( ( nb*( nb-1 ) ) / 2, ( np+nq )*nb ) + nb*nb
      sizemqrright = max( ( nb*( nb-1 ) ) / 2,
     $               ( nq+max( np+numroc( numroc( n+icoffa, nb, 0, 0,
     $               npcol ), nb, 0, 0, lcmq ), np ) )*nb ) + nb*nb
      sizeqrf = nb*np + nb*nq + nb*nb
      sizetms = ( lda+1 )*max( 1, nq ) +
     $          max( sizemqrleft, sizemqrright, sizeqrf )
*
      np0 = numroc( n, desca( mb_ ), 0, 0, nprow )
      mq0 = numroc( n, desca( nb_ ), 0, 0, npcol )
      sizeqtq = 2 + max( desca( mb_ ), 2 )*( 2*np0+mq0 )
      sizechk = numroc( n, desca( nb_ ), mycol, 0, npcol )
*
      neig = n
      nn = max( n, nb, 2 ) + 1
      np0 = numroc( nn, nb, 0, 0, nprow )
      mq0 = numroc( max( neig, nb, 2 ), nb, 0, 0, npcol )
      nnp = max( n, nprow*npcol+1, 4 )
*
*
      sizeheevr = 1+n + ( np0+mq0+nb )*nb
      sizeheevr = max(3, sizeheevr)
      rsizeheevr = 1 + 5*n + max( 18*nn, np0*mq0+2*nb*nb ) +
     $            (2 + iceil( neig, nprow*npcol ))*nn
      rsizeheevr = max(3, rsizeheevr)
*
      isizeheevr = 12*nnp + 2*n
*
      ictxt = desca( ctxt_ )
      anb = pjlaenv( ictxt, 3, 'PZHETTRD', 'L', 0, 0, 0, 0 )
      sqnpc = int( sqrt( dble( nprow*npcol ) ) )
      nps = max( numroc( n, 1, 0, 0, sqnpc ), 2*anb )
      nhetrd_lwopt = 2*( anb+1 )*( 4*nps+2 ) + ( nps+2 )*nps
      sizeheevr = max( sizeheevr, n + nhetrd_lwopt )
*
      sizesubtst = max( sizetms,  sizeheevr ) +
     $             iprepad + ipostpad
      rsizesubtst = max( sizeqtq, sizechk, rsizeheevr ) +
     $             iprepad + ipostpad
      isizesubtst = isizeheevr + iprepad + ipostpad
*
*     Allow room for A, COPYA, Z, WORK
*
      sizetst = 3*( lda*np+iprepad+ipostpad ) + sizesubtst
*
*     Allow room for DIAG, WIN, WNEW, GAP, RWORK
*
      rsizetst = 4*( n+iprepad+ipostpad ) + rsizesubtst
*
*     Allow room for IFAIL, ICLUSTR, and IWORK 
*     (only needed for PZHEEVX)
*
      isizetst = n + 2*nprow*npcol + 2*( iprepad+ipostpad ) +
     $           isizesubtst
*
*
      RETURN

Here is the caller graph for this function: