IAA

PCUNMBR()

if( (vect = 'q' and nq >= k) or (vect <> 'q' and nq > k) ),
IAA=ia; jaa=ja; mi=m; ni=n; icc=ic; jcc=jc
iaa=ia+1; jaa=ja; mi=m-1; ni=n; icc=ic+1; jcc=jc;

PCUNMHR()

IAA = ia + ilo; jaa = ja+ilo-1
mi = ihi-ilo; ni = n; icc = ic + ilo; jcc = jc;

PCUNMTR()

if uplo = 'u',
IAA = ia, jaa = ja+1, icc = ic, jcc = jc
iaa = ia+1, jaa = ja;

PDORMBR()

if( (vect = 'q' and nq >= k) or (vect <> 'q' and nq > k) ),
IAA=ia; jaa=ja; mi=m; ni=n; icc=ic; jcc=jc
iaa=ia+1; jaa=ja; mi=m-1; ni=n; icc=ic+1; jcc=jc;

PDORMHR()

IAA = ia + ilo; jaa = ja+ilo-1
mi = ihi-ilo; ni = n; icc = ic + ilo; jcc = jc;

PDORMTR()

if uplo = 'u',
IAA = ia, jaa = ja+1, icc = ic, jcc = jc
iaa = ia+1, jaa = ja;

PSORMBR()

if( (vect = 'q' and nq >= k) or (vect <> 'q' and nq > k) ),
IAA=ia; jaa=ja; mi=m; ni=n; icc=ic; jcc=jc
iaa=ia+1; jaa=ja; mi=m-1; ni=n; icc=ic+1; jcc=jc;

PSORMHR()

IAA = ia + ilo; jaa = ja+ilo-1
mi = ihi-ilo; ni = n; icc = ic + ilo; jcc = jc;

PSORMTR()

if uplo = 'u',
IAA = ia, jaa = ja+1, icc = ic, jcc = jc
iaa = ia+1, jaa = ja;

PZUNMBR()

if( (vect = 'q' and nq >= k) or (vect <> 'q' and nq > k) ),
IAA=ia; jaa=ja; mi=m; ni=n; icc=ic; jcc=jc
iaa=ia+1; jaa=ja; mi=m-1; ni=n; icc=ic+1; jcc=jc;

PZUNMHR()

IAA = ia + ilo; jaa = ja+ilo-1
mi = ihi-ilo; ni = n; icc = ic + ilo; jcc = jc;

PZUNMTR()

if uplo = 'u',
IAA = ia, jaa = ja+1, icc = ic, jcc = jc
iaa = ia+1, jaa = ja;

IACOL

PCGEBD2()

iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb, mycol, csrc_a, npcol )
nqa0 = numroc( n+iroffa, nb, mycol, iacol, npcol ).

PCGEBRD()

iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb, mycol, iacol, npcol ).

PCGELQ2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PCGELQF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PCGELS()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PCGEQL2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PCGEQLF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PCGEQPF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PCGEQR2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PCGEQRF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PCGERQ2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PCGERQF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PCGGQRF()

iarow  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL  = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
mqa0   = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PCGGRQF()

iarow  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL  = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0   = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PCHEEVD()

np = numroc( n, nb, myrow, iarow, nprow )
nq = numroc( n, nb, mycol, IACOL, npcol 
iwork   (local workspace/output) integer array, dimension (liwork)

PCLABRD()

nq = numroc( n+mod( ia-1, nb_y ), nb_y, mycol, IACOL, npcol 

PCLANGE()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PCLANHE()

gather the result on process (iarow,IACOL)

PCLANSY()

gather the result on process (iarow,IACOL)

PCLATRZ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PCTZRZF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PCUNG2L()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PCUNG2R()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PCUNGL2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PCUNGLQ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PCUNGQL()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PCUNGQR()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PCUNGR2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PCUNGRQ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PCUNMBR()

iarow = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( jaa, nb_a, mycol, csrc_a, npcol )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

PCUNML2()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PCUNMLQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

PCUNMR2()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PCUNMR3()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PCUNMRQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

PCUNMRZ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

PDGEBD2()

iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb, mycol, csrc_a, npcol )
nqa0 = numroc( n+iroffa, nb, mycol, iacol, npcol ).

PDGEBRD()

iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb, mycol, iacol, npcol ).

PDGELQ2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PDGELQF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PDGELS()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PDGEQL2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PDGEQLF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PDGEQPF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PDGEQR2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PDGEQRF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PDGERQ2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PDGERQF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PDGGQRF()

iarow  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL  = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
mqa0   = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PDGGRQF()

iarow  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL  = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0   = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PDLABRD()

nq = numroc( n+mod( ia-1, nb_y ), nb_y, mycol, IACOL, npcol 

PDLANGE()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PDLANSY()

gather the result on process (iarow,IACOL)

PDLATRZ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PDORG2L()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PDORG2R()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PDORGL2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PDORGLQ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PDORGQL()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PDORGQR()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PDORGR2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PDORGRQ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PDORMBR()

iarow = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( jaa, nb_a, mycol, csrc_a, npcol )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

PDORML2()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PDORMLQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

PDORMR2()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PDORMR3()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PDORMRQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

PDORMRZ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

PDSYEVD()

np = numroc( n, nb, myrow, iarow, nprow )
nq = numroc( n, nb, mycol, IACOL, npcol 
if lwork = -1, the lwork is global input and a workspace

PDTZRZF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PSGEBD2()

iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb, mycol, csrc_a, npcol )
nqa0 = numroc( n+iroffa, nb, mycol, iacol, npcol ).

PSGEBRD()

iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb, mycol, iacol, npcol ).

PSGELQ2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PSGELQF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PSGELS()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PSGEQL2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PSGEQLF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PSGEQPF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PSGEQR2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PSGEQRF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PSGERQ2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PSGERQF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PSGGQRF()

iarow  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL  = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
mqa0   = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PSGGRQF()

iarow  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL  = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0   = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PSLABRD()

nq = numroc( n+mod( ia-1, nb_y ), nb_y, mycol, IACOL, npcol 

PSLANGE()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PSLANSY()

gather the result on process (iarow,IACOL)

PSLATRZ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PSORG2L()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PSORG2R()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PSORGL2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PSORGLQ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PSORGQL()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PSORGQR()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PSORGR2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PSORGRQ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PSORMBR()

iarow = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( jaa, nb_a, mycol, csrc_a, npcol )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

PSORML2()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PSORMLQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

PSORMR2()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PSORMR3()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PSORMRQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

PSORMRZ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

PSSYEVD()

np = numroc( n, nb, myrow, iarow, nprow )
nq = numroc( n, nb, mycol, IACOL, npcol 
if lwork = -1, the lwork is global input and a workspace

PSTZRZF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZGEBD2()

iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb, mycol, csrc_a, npcol )
nqa0 = numroc( n+iroffa, nb, mycol, iacol, npcol ).

PZGEBRD()

iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb, mycol, iacol, npcol ).

PZGELQ2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZGELQF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZGELS()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PZGEQL2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZGEQLF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZGEQPF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZGEQR2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZGEQRF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZGERQ2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZGERQF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZGGQRF()

iarow  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL  = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
mqa0   = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PZGGRQF()

iarow  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL  = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0   = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PZHEEVD()

np = numroc( n, nb, myrow, iarow, nprow )
nq = numroc( n, nb, mycol, IACOL, npcol 
iwork   (local workspace/output) integer array, dimension (liwork)

PZLABRD()

nq = numroc( n+mod( ia-1, nb_y ), nb_y, mycol, IACOL, npcol 

PZLANGE()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PZLANHE()

gather the result on process (iarow,IACOL)

PZLANSY()

gather the result on process (iarow,IACOL)

PZLATRZ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZTZRZF()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nq0   = numroc( n+icoff, nb_a, mycol, iacol, npcol ),

PZUNG2L()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PZUNG2R()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PZUNGL2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PZUNGLQ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PZUNGQL()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PZUNGQR()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PZUNGR2()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PZUNGRQ()

iarow = indxg2p( ia, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )
nqa0 = numroc( n+icoffa, nb_a, mycol, iacol, npcol ),

PZUNMBR()

iarow = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow ),
IACOL = indxg2p( jaa, nb_a, mycol, csrc_a, npcol )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

PZUNML2()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PZUNMLQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

PZUNMR2()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PZUNMR3()

if side = 'r',
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. IACOL.eq.iccol 
=====================================================================

PZUNMRQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

PZUNMRZ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IACOL = indxg2p( ja, nb_a, mycol, csrc_a, npcol )

IAF

PCGERFS()

IAF     (global input) intege
row of sub( af ).

PCGESVX()

equilibrated before it is factored.
= 'f':  on entry, af(IAF:iaf+n-1,jaf:jaf+n-1) and ipiv con
if equed is not 'n', the matrix

PCPORFS()

IAF     (global input) intege
row of sub( af ).

PCPOSVX()

IAF     (global input) intege
row of sub( af ).

PDGERFS()

IAF     (global input) intege
row of sub( af ).

PDGESVX()

equilibrated before it is factored.
= 'f':  on entry, af(IAF:iaf+n-1,jaf:jaf+n-1) and ipiv con
if equed is not 'n', the matrix

PDPORFS()

IAF     (global input) intege
row of sub( af ).

PDPOSVX()

IAF     (global input) intege
row of sub( af ).

PSGERFS()

IAF     (global input) intege
row of sub( af ).

PSGESVX()

equilibrated before it is factored.
= 'f':  on entry, af(IAF:iaf+n-1,jaf:jaf+n-1) and ipiv con
if equed is not 'n', the matrix

PSPORFS()

IAF     (global input) intege
row of sub( af ).

PSPOSVX()

IAF     (global input) intege
row of sub( af ).

PZGERFS()

IAF     (global input) intege
row of sub( af ).

PZGESVX()

equilibrated before it is factored.
= 'f':  on entry, af(IAF:iaf+n-1,jaf:jaf+n-1) and ipiv con
if equed is not 'n', the matrix

PZPORFS()

IAF     (global input) intege
row of sub( af ).

PZPOSVX()

IAF     (global input) intege
row of sub( af ).

IAFIRST

PCLAHQR()

node (IAFIRST,jafirst) owns a(1,1

PDLAHQR()

node (IAFIRST,jafirst) owns a(1,1

PSLAHQR()

node (IAFIRST,jafirst) owns a(1,1

PZLAHQR()

node (IAFIRST,jafirst) owns a(1,1

iam

PCLAEVSWP()

zin     (local input) real array,
dimension ( ldzi, nvs(iam) 
in one process.  each process holds a contiguous set of

PDLAEVSWP()

zin     (local input) double precision array,
dimension ( ldzi, nvs(iam) 
in one process.  each process holds a contiguous set of

PSLAEVSWP()

zin     (local input) real array,
dimension ( ldzi, nvs(iam) 
in one process.  each process holds a contiguous set of

PZLAEVSWP()

zin     (local input) double precision array,
dimension ( ldzi, nvs(iam) 
in one process.  each process holds a contiguous set of

IAROW

PCGEBD2()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb )
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, nb, myrow, iarow, nprow ),

PCGEBRD()

iroffa = mod( ia-1, nb ), icoffa = mod( ja-1, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, nb, myrow, iarow, nprow ),

PCGEHD2()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )

PCGEHRD()

icoffa = mod( ja-1, nb ), ioff = mod( ia+ilo-2, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
ilrow = indxg2p( ia+ilo-1, nb, myrow, rsrc_a, nprow ),

PCGELQ2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PCGELQF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PCGELS()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PCGEQL2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PCGEQLF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PCGEQPF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PCGEQR2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PCGEQRF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PCGERQ2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PCGERQF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PCGGQRF()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
npa0   = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PCGGRQF()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0   = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PCHEEV()

( mb_a.eq.nb_a.eq.mb_z .and. iroffa.eq.iroffz .and. iroffa.eq.0 .and.
IAROW.eq.izrow 
iroffa = mod( ia-1, mb_a ) and icoffa = mod( ja-1, nb_a ).

PCHEEVD()

lrwork >= 1 + 9*n + 3*np*nq,
np = numroc( n, nb, myrow, IAROW, nprow 

PCHEEVX()

( mb_a.eq.nb_a.eq.mb_z .and. iroffa.eq.iroffz .and. iroffa.eq.0 .and.
IAROW.eq.izrow 
iroffa = mod( ia-1, mb_a ) and icoffa = mod( ja-1, nb_a ).

PCHETRD()

where nb = mb_a = nb_a,
np = numroc( n, nb, myrow, IAROW, nprow )

PCLANGE()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PCLANHE()

gather the result on process (IAROW,iacol)

PCLANSY()

gather the result on process (IAROW,iacol)

PCLATRZ()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PCTZRZF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PCUNG2L()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PCUNG2R()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PCUNGL2()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PCUNGLQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PCUNGQL()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PCUNGQR()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PCUNGR2()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PCUNGRQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PCUNM2L()

if side = 'l',
( mb_a.eq.mb_c .and. iroffa.eq.iroffc .and. IAROW.eq.icrow 
( mb_a.eq.nb_c .and. iroffa.eq.icoffc )

PCUNM2R()

if side = 'l',
( mb_a.eq.mb_c .and. iroffa.eq.iroffc .and. IAROW.eq.icrow 
( mb_a.eq.nb_c .and. iroffa.eq.icoffc )

PCUNMBR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )
mqa0 = numroc( mi+icoffa, nb_a, mycol, iacol, npcol ),

PCUNMHR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )

PCUNMQL()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )

PCUNMQR()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )

PCUNMTR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )

PDGEBD2()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb )
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, nb, myrow, iarow, nprow ),

PDGEBRD()

iroffa = mod( ia-1, nb ), icoffa = mod( ja-1, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, nb, myrow, iarow, nprow ),

PDGEHD2()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )

PDGEHRD()

icoffa = mod( ja-1, nb ), ioff = mod( ia+ilo-2, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
ilrow = indxg2p( ia+ilo-1, nb, myrow, rsrc_a, nprow ),

PDGELQ2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PDGELQF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PDGELS()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PDGEQL2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PDGEQLF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PDGEQPF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PDGEQR2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PDGEQRF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PDGERQ2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PDGERQF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PDGGQRF()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
npa0   = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PDGGRQF()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0   = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PDLANGE()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PDLANSY()

gather the result on process (IAROW,iacol)

PDLASRT()

where
np = numroc( n, nb, myrow, IAROW, nprow )

PDLATRZ()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PDORG2L()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PDORG2R()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PDORGL2()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PDORGLQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PDORGQL()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PDORGQR()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PDORGR2()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PDORGRQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PDORM2L()

if side = 'l',
( mb_a.eq.mb_c .and. iroffa.eq.iroffc .and. IAROW.eq.icrow 
( mb_a.eq.nb_c .and. iroffa.eq.icoffc )

PDORM2R()

if side = 'l',
( mb_a.eq.mb_c .and. iroffa.eq.iroffc .and. IAROW.eq.icrow 
( mb_a.eq.nb_c .and. iroffa.eq.icoffc )

PDORMBR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )
mqa0 = numroc( mi+icoffa, nb_a, mycol, iacol, npcol ),

PDORMHR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )

PDORMQL()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )

PDORMQR()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )

PDORMTR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )

PDSYEV()

( mb_a.eq.nb_a.eq.mb_z .and. iroffa.eq.iroffz .and. iroffa.eq.0 .and.
IAROW.eq.izrow 
iroffa = mod( ia-1, mb_a ) and icoffa = mod( ja-1, nb_a ).

PDSYEVD()

trilwmin = 3*n + max( nb*( np+1 ), 3*nb )
np = numroc( n, nb, myrow, IAROW, nprow 

PDSYEVX()

( mb_a.eq.nb_a.eq.mb_z .and. iroffa.eq.iroffz .and. iroffa.eq.0 .and.
IAROW.eq.izrow 
iroffa = mod( ia-1, mb_a ) and icoffa = mod( ja-1, nb_a ).

PDSYTRD()

where nb = mb_a = nb_a,
np = numroc( n, nb, myrow, IAROW, nprow )

PDTZRZF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PSGEBD2()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb )
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, nb, myrow, iarow, nprow ),

PSGEBRD()

iroffa = mod( ia-1, nb ), icoffa = mod( ja-1, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, nb, myrow, iarow, nprow ),

PSGEHD2()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )

PSGEHRD()

icoffa = mod( ja-1, nb ), ioff = mod( ia+ilo-2, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
ilrow = indxg2p( ia+ilo-1, nb, myrow, rsrc_a, nprow ),

PSGELQ2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PSGELQF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PSGELS()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PSGEQL2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PSGEQLF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PSGEQPF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PSGEQR2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PSGEQRF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PSGERQ2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PSGERQF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PSGGQRF()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
npa0   = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PSGGRQF()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0   = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PSLANGE()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PSLANSY()

gather the result on process (IAROW,iacol)

PSLASRT()

where
np = numroc( n, nb, myrow, IAROW, nprow )

PSLATRZ()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PSORG2L()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PSORG2R()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PSORGL2()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PSORGLQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PSORGQL()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PSORGQR()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PSORGR2()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PSORGRQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PSORM2L()

if side = 'l',
( mb_a.eq.mb_c .and. iroffa.eq.iroffc .and. IAROW.eq.icrow 
( mb_a.eq.nb_c .and. iroffa.eq.icoffc )

PSORM2R()

if side = 'l',
( mb_a.eq.mb_c .and. iroffa.eq.iroffc .and. IAROW.eq.icrow 
( mb_a.eq.nb_c .and. iroffa.eq.icoffc )

PSORMBR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )
mqa0 = numroc( mi+icoffa, nb_a, mycol, iacol, npcol ),

PSORMHR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )

PSORMQL()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )

PSORMQR()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )

PSORMTR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )

PSSYEV()

( mb_a.eq.nb_a.eq.mb_z .and. iroffa.eq.iroffz .and. iroffa.eq.0 .and.
IAROW.eq.izrow 
iroffa = mod( ia-1, mb_a ) and icoffa = mod( ja-1, nb_a ).

PSSYEVD()

trilwmin = 3*n + max( nb*( np+1 ), 3*nb )
np = numroc( n, nb, myrow, IAROW, nprow 

PSSYEVX()

( mb_a.eq.nb_a.eq.mb_z .and. iroffa.eq.iroffz .and. iroffa.eq.0 .and.
IAROW.eq.izrow 
iroffa = mod( ia-1, mb_a ) and icoffa = mod( ja-1, nb_a ).

PSSYTRD()

where nb = mb_a = nb_a,
np = numroc( n, nb, myrow, IAROW, nprow )

PSTZRZF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZGEBD2()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb )
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, nb, myrow, iarow, nprow ),

PZGEBRD()

iroffa = mod( ia-1, nb ), icoffa = mod( ja-1, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, nb, myrow, iarow, nprow ),

PZGEHD2()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )

PZGEHRD()

icoffa = mod( ja-1, nb ), ioff = mod( ia+ilo-2, nb ),
IAROW = indxg2p( ia, nb, myrow, rsrc_a, nprow )
ilrow = indxg2p( ia+ilo-1, nb, myrow, rsrc_a, nprow ),

PZGELQ2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZGELQF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZGELS()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PZGEQL2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZGEQLF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZGEQPF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZGEQR2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZGEQRF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZGERQ2()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZGERQF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZGGQRF()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
npa0   = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PZGGRQF()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW  = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0   = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PZHEEV()

( mb_a.eq.nb_a.eq.mb_z .and. iroffa.eq.iroffz .and. iroffa.eq.0 .and.
IAROW.eq.izrow 
iroffa = mod( ia-1, mb_a ) and icoffa = mod( ja-1, nb_a ).

PZHEEVD()

lrwork >= 1 + 9*n + 3*np*nq,
np = numroc( n, nb, myrow, IAROW, nprow 

PZHEEVX()

( mb_a.eq.nb_a.eq.mb_z .and. iroffa.eq.iroffz .and. iroffa.eq.0 .and.
IAROW.eq.izrow 
iroffa = mod( ia-1, mb_a ) and icoffa = mod( ja-1, nb_a ).

PZHETRD()

where nb = mb_a = nb_a,
np = numroc( n, nb, myrow, IAROW, nprow )

PZLANGE()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PZLANHE()

gather the result on process (IAROW,iacol)

PZLANSY()

gather the result on process (IAROW,iacol)

PZLATRZ()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZTZRZF()

iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mp0   = numroc( m+iroff, mb_a, myrow, iarow, nprow ),

PZUNG2L()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PZUNG2R()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PZUNGL2()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PZUNGLQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PZUNGQL()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PZUNGQR()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PZUNGR2()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PZUNGRQ()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )
mpa0 = numroc( m+iroffa, mb_a, myrow, iarow, nprow ),

PZUNM2L()

if side = 'l',
( mb_a.eq.mb_c .and. iroffa.eq.iroffc .and. IAROW.eq.icrow 
( mb_a.eq.nb_c .and. iroffa.eq.icoffc )

PZUNM2R()

if side = 'l',
( mb_a.eq.mb_c .and. iroffa.eq.iroffc .and. IAROW.eq.icrow 
( mb_a.eq.nb_c .and. iroffa.eq.icoffc )

PZUNMBR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )
mqa0 = numroc( mi+icoffa, nb_a, mycol, iacol, npcol ),

PZUNMHR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )

PZUNMQL()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )

PZUNMQR()

iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),
IAROW = indxg2p( ia, mb_a, myrow, rsrc_a, nprow )

PZUNMTR()

iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),
IAROW = indxg2p( iaa, mb_a, myrow, rsrc_a, nprow )

iax

PCLARFG()

h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ),   h' * h = i

PDLARFG()

h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ),   h' * h = i

PSLARFG()

h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ),   h' * h = i

PZLARFG()

h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ),   h' * h = i

IB1

PDLAED2()

nn2    (global output) integer, the order of matrix q2, (pdlaed1).
IB1    (global output) integer, pointeur on q1, (pdlaed1)

PSLAED2()

nn2    (global output) integer, the order of matrix q2, (pslaed1).
IB1    (global output) integer, pointeur on q1, (pslaed1)

IB2

PDLAED2()

ib1    (global output) integer, pointeur on q1, (pdlaed1).
IB2    (global output) integer, pointeur on q2, (pdlaed1)
=====================================================================

PSLAED2()

ib1    (global output) integer, pointeur on q1, (pslaed1).
IB2    (global output) integer, pointeur on q2, (pslaed1)
=====================================================================

IBCOL

PCGELS()

ibrow = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
npb0 = numroc( n+iroffb, mb_b, myrow, ibrow, nprow ),

PCGGQRF()

ibrow  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL  = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
pqb0   = numroc( p+icoffb, nb_b, mycol, ibcol, npcol ),

PCGGRQF()

ibrow  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL  = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
nqb0   = numroc( n+icoffb, nb_b, mycol, ibcol, npcol ),

PDGELS()

ibrow = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
npb0 = numroc( n+iroffb, mb_b, myrow, ibrow, nprow ),

PDGGQRF()

ibrow  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL  = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
pqb0   = numroc( p+icoffb, nb_b, mycol, ibcol, npcol ),

PDGGRQF()

ibrow  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL  = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
nqb0   = numroc( n+icoffb, nb_b, mycol, ibcol, npcol ),

PSGELS()

ibrow = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
npb0 = numroc( n+iroffb, mb_b, myrow, ibrow, nprow ),

PSGGQRF()

ibrow  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL  = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
pqb0   = numroc( p+icoffb, nb_b, mycol, ibcol, npcol ),

PSGGRQF()

ibrow  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL  = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
nqb0   = numroc( n+icoffb, nb_b, mycol, ibcol, npcol ),

PZGELS()

ibrow = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
npb0 = numroc( n+iroffb, mb_b, myrow, ibrow, nprow ),

PZGGQRF()

ibrow  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL  = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
pqb0   = numroc( p+icoffb, nb_b, mycol, ibcol, npcol ),

PZGGRQF()

ibrow  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow ),
IBCOL  = indxg2p( jb, nb_b, mycol, csrc_b, npcol )
nqb0   = numroc( n+icoffb, nb_b, mycol, ibcol, npcol ),

IBLK

PCLAHQR()

the main loop begins here. i is the loop index and decreases from
ihi to ilo in steps of our schur block size (<=2*IBLK). eac
and columns l to i.   eigenvalues i+1 to ihi have already

PDLAHQR()

the main loop begins here. i is the loop index and decreases from
ihi to ilo in steps of our schur block size (<=2*IBLK). eac
and columns l to i.   eigenvalues i+1 to ihi have already

PSLAHQR()

the main loop begins here. i is the loop index and decreases from
ihi to ilo in steps of our schur block size (<=2*IBLK). eac
and columns l to i.   eigenvalues i+1 to ihi have already

PZLAHQR()

the main loop begins here. i is the loop index and decreases from
ihi to ilo in steps of our schur block size (<=2*IBLK). eac
and columns l to i.   eigenvalues i+1 to ihi have already

IBLOCK

PCSTEIN()

IBLOCK  (global input) integer array, dimension (n
eigenvalues in w -- 1 for eigenvalues belonging to the

PDSTEBZ()

specifies the order in which the eigenvalues and their block
numbers are stored in w and IBLOCK
split-off block (see iblock, isplit) and

PDSTEIN()

IBLOCK  (global input) integer array, dimension (n
eigenvalues in w -- 1 for eigenvalues belonging to the

PSSTEBZ()

specifies the order in which the eigenvalues and their block
numbers are stored in w and IBLOCK
split-off block (see iblock, isplit) and

PSSTEIN()

IBLOCK  (global input) integer array, dimension (n
eigenvalues in w -- 1 for eigenvalues belonging to the

PZSTEIN()

IBLOCK  (global input) integer array, dimension (n
eigenvalues in w -- 1 for eigenvalues belonging to the

IBROW

PCGELS()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
mpb0 = numroc( m+iroffb, mb_b, myrow, ibrow, nprow ),

PCGGQRF()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
npb0   = numroc( n+iroffb, mb_b, myrow, ibrow, nprow ),

PCGGRQF()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
ppb0   = numroc( p+iroffb, mb_b, myrow, ibrow, nprow ),

PDGELS()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
mpb0 = numroc( m+iroffb, mb_b, myrow, ibrow, nprow ),

PDGGQRF()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
npb0   = numroc( n+iroffb, mb_b, myrow, ibrow, nprow ),

PDGGRQF()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
ppb0   = numroc( p+iroffb, mb_b, myrow, ibrow, nprow ),

PSGELS()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
mpb0 = numroc( m+iroffb, mb_b, myrow, ibrow, nprow ),

PSGGQRF()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
npb0   = numroc( n+iroffb, mb_b, myrow, ibrow, nprow ),

PSGGRQF()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
ppb0   = numroc( p+iroffb, mb_b, myrow, ibrow, nprow ),

PZGELS()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
mpb0 = numroc( m+iroffb, mb_b, myrow, ibrow, nprow ),

PZGGQRF()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
npb0   = numroc( n+iroffb, mb_b, myrow, ibrow, nprow ),

PZGGRQF()

iroffb = mod( ib-1, mb_b ), icoffb = mod( jb-1, nb_b ),
IBROW  = indxg2p( ib, mb_b, myrow, rsrc_b, nprow )
ppb0   = numroc( p+iroffb, mb_b, myrow, ibrow, nprow ),

IBTYPE

PCHEGS2()

if IBTYPE = 1, the problem is sub( a )*x = lambda*sub( b )*x
inv(l)*sub( a )*inv(l**h)

PCHEGST()

if IBTYPE = 1, the problem is sub( a )*x = lambda*sub( b )*x
inv(l)*sub( a )*inv(l**h)

PCHEGVX()

IBTYPE   (global input) intege
= 1:  sub( a )*x = (lambda)*sub( b )*x

PCHENGST()

pchengst calls pchegst when uplo='u', hence pchengst provides
improved performance only when uplo='l', IBTYPE=1
pchengst also calls pchegst when insufficient workspace is

PDSYGS2()

if IBTYPE = 1, the problem is sub( a )*x = lambda*sub( b )*x
inv(l)*sub( a )*inv(l**t)

PDSYGST()

if IBTYPE = 1, the problem is sub( a )*x = lambda*sub( b )*x
inv(l)*sub( a )*inv(l**t)

PDSYGVX()

IBTYPE   (global input) intege
= 1:  sub( a )*x = (lambda)*sub( b )*x

PDSYNGST()

pdsyngst calls pdhegst when uplo='u', hence pdhengst provides
improved performance only when uplo='l', IBTYPE=1
pdsyngst also calls pdhegst when insufficient workspace is

PSSYGS2()

if IBTYPE = 1, the problem is sub( a )*x = lambda*sub( b )*x
inv(l)*sub( a )*inv(l**t)

PSSYGST()

if IBTYPE = 1, the problem is sub( a )*x = lambda*sub( b )*x
inv(l)*sub( a )*inv(l**t)

PSSYGVX()

IBTYPE   (global input) intege
= 1:  sub( a )*x = (lambda)*sub( b )*x

PSSYNGST()

pssyngst calls pshegst when uplo='u', hence pshengst provides
improved performance only when uplo='l', IBTYPE=1
pssyngst also calls pshegst when insufficient workspace is

PZHEGS2()

if IBTYPE = 1, the problem is sub( a )*x = lambda*sub( b )*x
inv(l)*sub( a )*inv(l**h)

PZHEGST()

if IBTYPE = 1, the problem is sub( a )*x = lambda*sub( b )*x
inv(l)*sub( a )*inv(l**h)

PZHEGVX()

IBTYPE   (global input) intege
= 1:  sub( a )*x = (lambda)*sub( b )*x

PZHENGST()

pzhengst calls pzhegst when uplo='u', hence pzhengst provides
improved performance only when uplo='l', IBTYPE=1
pzhengst also calls pzhegst when insufficient workspace is

IBULGE

PCLAHQR()

IBULGE is the number of bulges going so fa

PDLAHQR()

IBULGE is the number of bulges going so fa

PSLAHQR()

IBULGE is the number of bulges going so fa

PZLAHQR()

IBULGE is the number of bulges going so fa

ICC

PCUNMBR()

if( (vect = 'q' and nq >= k) or (vect <> 'q' and nq > k) ),
iaa=ia; jaa=ja; mi=m; ni=n; ICC=ic; jcc=jc
iaa=ia+1; jaa=ja; mi=m-1; ni=n; icc=ic+1; jcc=jc;

PCUNMHR()

if side = 'l',
mi = ihi-ilo; ni = n; ICC = ic + ilo; jcc = jc
nb_a * nb_a

PCUNMTR()

if uplo = 'u',
iaa = ia, jaa = ja+1, ICC = ic, jcc = jc
iaa = ia+1, jaa = ja;

PDORMBR()

if( (vect = 'q' and nq >= k) or (vect <> 'q' and nq > k) ),
iaa=ia; jaa=ja; mi=m; ni=n; ICC=ic; jcc=jc
iaa=ia+1; jaa=ja; mi=m-1; ni=n; icc=ic+1; jcc=jc;

PDORMHR()

if side = 'l',
mi = ihi-ilo; ni = n; ICC = ic + ilo; jcc = jc
nb_a * nb_a

PDORMTR()

if uplo = 'u',
iaa = ia, jaa = ja+1, ICC = ic, jcc = jc
iaa = ia+1, jaa = ja;

PSORMBR()

if( (vect = 'q' and nq >= k) or (vect <> 'q' and nq > k) ),
iaa=ia; jaa=ja; mi=m; ni=n; ICC=ic; jcc=jc
iaa=ia+1; jaa=ja; mi=m-1; ni=n; icc=ic+1; jcc=jc;

PSORMHR()

if side = 'l',
mi = ihi-ilo; ni = n; ICC = ic + ilo; jcc = jc
nb_a * nb_a

PSORMTR()

if uplo = 'u',
iaa = ia, jaa = ja+1, ICC = ic, jcc = jc
iaa = ia+1, jaa = ja;

PZUNMBR()

if( (vect = 'q' and nq >= k) or (vect <> 'q' and nq > k) ),
iaa=ia; jaa=ja; mi=m; ni=n; ICC=ic; jcc=jc
iaa=ia+1; jaa=ja; mi=m-1; ni=n; icc=ic+1; jcc=jc;

PZUNMHR()

if side = 'l',
mi = ihi-ilo; ni = n; ICC = ic + ilo; jcc = jc
nb_a * nb_a

PZUNMTR()

if uplo = 'u',
iaa = ia, jaa = ja+1, ICC = ic, jcc = jc
iaa = ia+1, jaa = ja;

ICCOL

PCLARF()

send v and tau to the process column ICCOL

PCLARFB()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
npc0 = numroc( n+icoffc, mb_c, myrow, icrow, nprow ),

PCLARFC()

send v and tau to the process column ICCOL

PCLARZB()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
npc0 = numroc( n+icoffc, mb_c, myrow, icrow, nprow ),

PCUNM2L()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PCUNM2R()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PCUNMBR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

PCUNMHR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

PCUNML2()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PCUNMLQ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PCUNMQL()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PCUNMQR()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PCUNMR2()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PCUNMR3()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PCUNMRQ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PCUNMRZ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PCUNMTR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

PDLARF()

send v and tau to the process column ICCOL

PDLARFB()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
npc0 = numroc( n+icoffc, mb_c, myrow, icrow, nprow ),

PDLARZB()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
npc0 = numroc( n+icoffc, mb_c, myrow, icrow, nprow ),

PDORM2L()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PDORM2R()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PDORMBR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

PDORMHR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

PDORML2()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PDORMLQ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PDORMQL()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PDORMQR()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PDORMR2()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PDORMR3()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PDORMRQ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PDORMRZ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PDORMTR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

PSLARF()

send v and tau to the process column ICCOL

PSLARFB()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
npc0 = numroc( n+icoffc, mb_c, myrow, icrow, nprow ),

PSLARZB()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
npc0 = numroc( n+icoffc, mb_c, myrow, icrow, nprow ),

PSORM2L()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PSORM2R()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PSORMBR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

PSORMHR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

PSORML2()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PSORMLQ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PSORMQL()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PSORMQR()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PSORMR2()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PSORMR3()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PSORMRQ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PSORMRZ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PSORMTR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

PZLARF()

send v and tau to the process column ICCOL

PZLARFB()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
npc0 = numroc( n+icoffc, mb_c, myrow, icrow, nprow ),

PZLARFC()

send v and tau to the process column ICCOL

PZLARZB()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
npc0 = numroc( n+icoffc, mb_c, myrow, icrow, nprow ),

PZUNM2L()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PZUNM2R()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PZUNMBR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

PZUNMHR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

PZUNML2()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PZUNMLQ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PZUNMQL()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PZUNMQR()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PZUNMR2()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PZUNMR3()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PZUNMRQ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PZUNMRZ()

icrow = indxg2p( ic, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( n+icoffc, nb_c, mycol, iccol, npcol ),

PZUNMTR()

icrow = indxg2p( icc, mb_c, myrow, rsrc_c, nprow ),
ICCOL = indxg2p( jcc, nb_c, mycol, csrc_c, npcol )
nqc0 = numroc( ni+icoffc, nb_c, mycol, iccol, npcol ),

ICCOL2

PCLARZ()

send v and tau to the process column ICCOL2

PCLARZC()

send v and tau to the process column ICCOL2

PDLARZ()

send v and tau to the process column ICCOL2

PSLARZ()

send v and tau to the process column ICCOL2

PZLARZ()

send v and tau to the process column ICCOL2

PZLARZC()

send v and tau to the process column ICCOL2

ICEIL

PCHEEVX()

lrwork >= 4*n + max( 5*nn, np0 * mq0 ) +
ICEIL( neig, nprow*npcol)*n
the computed eigenvectors may not be orthogonal if the

PCHEGVX()

lrwork >= 4*n + max( 5*nn, np0 * mq0 ) +
ICEIL( neig, nprow*npcol)*n
the computed eigenvectors may not be orthogonal if the

PDSYEVX()

lwork >= 5*n + max( 5*nn, np0 * mq0 + 2 * nb * nb ) +
ICEIL( neig, nprow*npcol)*n
the computed eigenvectors may not be orthogonal if the

PDSYGVX()

lwork >= 5 * n + max( 5*nn, np0 * mq0 + 2 * nb * nb ) +
ICEIL( neig, nprow*npcol)*n
the computed eigenvectors may not be orthogonal if the

PSSYEVX()

lwork >= 5*n + max( 5*nn, np0 * mq0 + 2 * nb * nb ) +
ICEIL( neig, nprow*npcol)*n
the computed eigenvectors may not be orthogonal if the

PSSYGVX()

lwork >= 5 * n + max( 5*nn, np0 * mq0 + 2 * nb * nb ) +
ICEIL( neig, nprow*npcol)*n
the computed eigenvectors may not be orthogonal if the

PZHEEVX()

lrwork >= 4*n + max( 5*nn, np0 * mq0 ) +
ICEIL( neig, nprow*npcol)*n
the computed eigenvectors may not be orthogonal if the

PZHEGVX()

lrwork >= 4*n + max( 5*nn, np0 * mq0 ) +
ICEIL( neig, nprow*npcol)*n
the computed eigenvectors may not be orthogonal if the

ICLM

PCLARFB()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ),

PCLARZB()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ),

PCUNM2L()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PCUNM2R()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PCUNMBR()

where lcmp = lcm / nprow, lcmq = lcm / npcol, with
lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

PCUNMHR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

PCUNML2()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PCUNMLQ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PCUNMQL()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PCUNMQR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PCUNMR2()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PCUNMR3()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PCUNMRQ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PCUNMRZ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PCUNMTR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

PDLARFB()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ),

PDLARZB()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ),

PDORM2L()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PDORM2R()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PDORMBR()

where lcmp = lcm / nprow, lcmq = lcm / npcol, with
lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

PDORMHR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

PDORML2()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PDORMLQ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PDORMQL()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PDORMQR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PDORMR2()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PDORMR3()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PDORMRQ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PDORMRZ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PDORMTR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

PSLARFB()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ),

PSLARZB()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ),

PSORM2L()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PSORM2R()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PSORMBR()

where lcmp = lcm / nprow, lcmq = lcm / npcol, with
lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

PSORMHR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

PSORML2()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PSORMLQ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PSORMQL()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PSORMQR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PSORMR2()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PSORMR3()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PSORMRQ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PSORMRZ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PSORMTR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

PZLARFB()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ),

PZLARZB()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ),

PZUNM2L()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PZUNM2R()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PZUNMBR()

where lcmp = lcm / nprow, lcmq = lcm / npcol, with
lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

PZUNMHR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

PZUNML2()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PZUNMLQ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PZUNMQL()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PZUNMQR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PZUNMR2()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PZUNMR3()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),

PZUNMRQ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PZUNMRZ()

where lcmp = lcm / nprow with lcm = ICLM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PZUNMTR()

where lcmq = lcm / npcol with lcm = ICLM( nprow, npcol )
iroffa = mod( iaa-1, mb_a ), icoffa = mod( jaa-1, nb_a ),

ICLUSTER

PCHEEVX()

orfac, ICLUSTER() and gap() parameters adde

PDSYEVX()

orfac, ICLUSTER() and gap() parameters adde

PSSYEVX()

orfac, ICLUSTER() and gap() parameters adde

PZHEEVX()

orfac, ICLUSTER() and gap() parameters adde

ICLUSTR

PCHEEVX()

ICLUSTR (global output) integer array, dimension (2*nprow*npcol
a cluster of eigenvalues that could not be reorthogonalized

PCHEGVX()

ICLUSTR (global output) integer array, dimension (2*nprow*npcol
a cluster of eigenvalues that could not be reorthogonalized

PCSTEIN()

ICLUSTR (global output) integer array, dimension (2*p
corresponding to a cluster of eigenvalues that could not be

PDSTEIN()

ICLUSTR (global output) integer array, dimension (2*p
corresponding to a cluster of eigenvalues that could not be

PDSYEVX()

ICLUSTR (global output) integer array, dimension (2*nprow*npcol
a cluster of eigenvalues that could not be reorthogonalized

PDSYGVX()

ICLUSTR (global output) integer array, dimension (2*nprow*npcol
a cluster of eigenvalues that could not be reorthogonalized

PSSTEIN()

ICLUSTR (global output) integer array, dimension (2*p
corresponding to a cluster of eigenvalues that could not be

PSSYEVX()

ICLUSTR (global output) integer array, dimension (2*nprow*npcol
a cluster of eigenvalues that could not be reorthogonalized

PSSYGVX()

ICLUSTR (global output) integer array, dimension (2*nprow*npcol
a cluster of eigenvalues that could not be reorthogonalized

PZHEEVX()

ICLUSTR (global output) integer array, dimension (2*nprow*npcol
a cluster of eigenvalues that could not be reorthogonalized

PZHEGVX()

ICLUSTR (global output) integer array, dimension (2*nprow*npcol
a cluster of eigenvalues that could not be reorthogonalized

PZSTEIN()

ICLUSTR (global output) integer array, dimension (2*p
corresponding to a cluster of eigenvalues that could not be

ICOFF

PCGELQ2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCGELQF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCGEQL2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCGEQLF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCGEQPF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCGEQR2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCGEQRF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCGERQ2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCGERQF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCLATRZ()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCTZRZF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDGELQ2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDGELQF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDGEQL2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDGEQLF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDGEQPF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDGEQR2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDGEQRF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDGERQ2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDGERQF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDLATRZ()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDTZRZF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSGELQ2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSGELQF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSGEQL2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSGEQLF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSGEQPF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSGEQR2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSGEQRF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSGERQ2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSGERQF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSLATRZ()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSTZRZF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZGELQ2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZGELQF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZGEQL2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZGEQLF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZGEQPF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZGEQR2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZGEQRF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZGERQ2()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZGERQF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZLATRZ()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZTZRZF()

iroff = mod( ia-1, mb_a ), ICOFF = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

ICOFFA

PCGEBD2()

ties, namely the following expressions should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA 
=====================================================================

PCGEBRD()

where nb = mb_a = nb_a,
iroffa = mod( ia-1, nb ), ICOFFA = mod( ja-1, nb )
iacol = indxg2p( ja, nb, mycol, csrc_a, npcol ),

PCGEHD2()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA 
=====================================================================

PCGEHRD()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),
ICOFFA = mod( ja-1, nb ), ioff = mod( ia+ilo-2, nb )
ihip = numroc( ihi+iroffa, nb, myrow, iarow, nprow ),

PCGELS()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCGGQRF()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol  = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCGGRQF()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol  = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCHEEV()

where
iroffa = mod( ia-1, mb_a ) and ICOFFA = mod( ja-1, nb_a )
=====================================================================

PCHEEVD()

should be true:
( mb_a.eq.nb_a.eq.mb_z.eq.nb_z .and. iroffa.eq.ICOFFA .and
with iroffa = mod( ia-1, mb_a )

PCHEEVX()

where
iroffa = mod( ia-1, mb_a ) and ICOFFA = mod( ja-1, nb_a )
=====================================================================

PCHENTRD()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA .and. iroffa.eq.0 ) wit

PCHETD2()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA ) wit

PCHETRD()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA .and. iroffa.eq.0 ) wit

PCLANGE()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCUNG2L()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCUNG2R()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCUNGL2()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCUNGLQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCUNGQL()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCUNGQR()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCUNGR2()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCUNGRQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PCUNMBR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
iacol = indxg2p( jaa, nb_a, mycol, csrc_a, npcol ),

PCUNMHR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

PCUNML2()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PCUNMLQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PCUNMQL()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
npa0 = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PCUNMQR()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
npa0 = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PCUNMR2()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PCUNMR3()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PCUNMRQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PCUNMRZ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PCUNMTR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

PDGEBD2()

ties, namely the following expressions should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA 
=====================================================================

PDGEBRD()

where nb = mb_a = nb_a,
iroffa = mod( ia-1, nb ), ICOFFA = mod( ja-1, nb )
iacol = indxg2p( ja, nb, mycol, csrc_a, npcol ),

PDGEHD2()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA 
=====================================================================

PDGEHRD()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),
ICOFFA = mod( ja-1, nb ), ioff = mod( ia+ilo-2, nb )
ihip = numroc( ihi+iroffa, nb, myrow, iarow, nprow ),

PDGELS()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDGGQRF()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol  = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDGGRQF()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol  = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDLANGE()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDORG2L()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDORG2R()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDORGL2()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDORGLQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDORGQL()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDORGQR()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDORGR2()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDORGRQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PDORMBR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
iacol = indxg2p( jaa, nb_a, mycol, csrc_a, npcol ),

PDORMHR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

PDORML2()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PDORMLQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PDORMQL()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
npa0 = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PDORMQR()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
npa0 = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PDORMR2()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PDORMR3()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PDORMRQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PDORMRZ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PDORMTR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

PDSYEV()

where
iroffa = mod( ia-1, mb_a ) and ICOFFA = mod( ja-1, nb_a )
=====================================================================

PDSYEVD()

should be true:
( mb_a.eq.nb_a.eq.mb_z.eq.nb_z .and. iroffa.eq.ICOFFA .and
with iroffa = mod( ia-1, mb_a )

PDSYEVX()

where
iroffa = mod( ia-1, mb_a ) and ICOFFA = mod( ja-1, nb_a )
=====================================================================

PDSYNTRD()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA .and. iroffa.eq.0 ) wit

PDSYTD2()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA ) wit

PDSYTRD()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA .and. iroffa.eq.0 ) wit

PSGEBD2()

ties, namely the following expressions should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA 
=====================================================================

PSGEBRD()

where nb = mb_a = nb_a,
iroffa = mod( ia-1, nb ), ICOFFA = mod( ja-1, nb )
iacol = indxg2p( ja, nb, mycol, csrc_a, npcol ),

PSGEHD2()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA 
=====================================================================

PSGEHRD()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),
ICOFFA = mod( ja-1, nb ), ioff = mod( ia+ilo-2, nb )
ihip = numroc( ihi+iroffa, nb, myrow, iarow, nprow ),

PSGELS()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSGGQRF()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol  = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSGGRQF()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol  = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSLANGE()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSORG2L()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSORG2R()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSORGL2()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSORGLQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSORGQL()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSORGQR()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSORGR2()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSORGRQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PSORMBR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
iacol = indxg2p( jaa, nb_a, mycol, csrc_a, npcol ),

PSORMHR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

PSORML2()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PSORMLQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PSORMQL()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
npa0 = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PSORMQR()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
npa0 = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PSORMR2()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PSORMR3()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PSORMRQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PSORMRZ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PSORMTR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

PSSYEV()

where
iroffa = mod( ia-1, mb_a ) and ICOFFA = mod( ja-1, nb_a )
=====================================================================

PSSYEVD()

should be true:
( mb_a.eq.nb_a.eq.mb_z.eq.nb_z .and. iroffa.eq.ICOFFA .and
with iroffa = mod( ia-1, mb_a )

PSSYEVX()

where
iroffa = mod( ia-1, mb_a ) and ICOFFA = mod( ja-1, nb_a )
=====================================================================

PSSYNTRD()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA .and. iroffa.eq.0 ) wit

PSSYTD2()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA ) wit

PSSYTRD()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA .and. iroffa.eq.0 ) wit

PZGEBD2()

ties, namely the following expressions should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA 
=====================================================================

PZGEBRD()

where nb = mb_a = nb_a,
iroffa = mod( ia-1, nb ), ICOFFA = mod( ja-1, nb )
iacol = indxg2p( ja, nb, mycol, csrc_a, npcol ),

PZGEHD2()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA 
=====================================================================

PZGEHRD()

where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),
ICOFFA = mod( ja-1, nb ), ioff = mod( ia+ilo-2, nb )
ihip = numroc( ihi+iroffa, nb, myrow, iarow, nprow ),

PZGELS()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZGGQRF()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol  = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZGGRQF()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol  = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZHEEV()

where
iroffa = mod( ia-1, mb_a ) and ICOFFA = mod( ja-1, nb_a )
=====================================================================

PZHEEVD()

should be true:
( mb_a.eq.nb_a.eq.mb_z.eq.nb_z .and. iroffa.eq.ICOFFA .and
with iroffa = mod( ia-1, mb_a )

PZHEEVX()

where
iroffa = mod( ia-1, mb_a ) and ICOFFA = mod( ja-1, nb_a )
=====================================================================

PZHENTRD()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA .and. iroffa.eq.0 ) wit

PZHETD2()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA ) wit

PZHETRD()

ties, namely the following expression should be true:
( mb_a.eq.nb_a .and. iroffa.eq.ICOFFA .and. iroffa.eq.0 ) wit

PZLANGE()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZUNG2L()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZUNG2R()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZUNGL2()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZUNGLQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZUNGQL()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZUNGQR()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZUNGR2()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZUNGRQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
iacol = indxg2p( ja, nb_a, mycol, csrc_a, npcol ),

PZUNMBR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
iacol = indxg2p( jaa, nb_a, mycol, csrc_a, npcol ),

PZUNMHR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

PZUNML2()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PZUNMLQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PZUNMQL()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
npa0 = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PZUNMQR()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
npa0 = numroc( n+iroffa, mb_a, myrow, iarow, nprow ),

PZUNMR2()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PZUNMR3()

if side = 'l',
( nb_a.eq.mb_c .and. ICOFFA.eq.iroffc 
( nb_a.eq.nb_c .and. icoffa.eq.icoffc .and. iacol.eq.iccol )

PZUNMRQ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PZUNMRZ()

iroffa = mod( ia-1, mb_a ), ICOFFA = mod( ja-1, nb_a )
mqa0 = numroc( m+icoffa, nb_a, mycol, iacol, npcol ),

PZUNMTR()

iroffa = mod( iaa-1, mb_a ), ICOFFA = mod( jaa-1, nb_a )
npa0 = numroc( ni+iroffa, mb_a, myrow, iarow, nprow ),

ICOFFB

PCGELS()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

PCGGQRF()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol  = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

PCGGRQF()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol  = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

PDGELS()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

PDGGQRF()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol  = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

PDGGRQF()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol  = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

PSGELS()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

PSGGQRF()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol  = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

PSGGRQF()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol  = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

PZGELS()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

PZGGQRF()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol  = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

PZGGRQF()

iroffb = mod( ib-1, mb_b ), ICOFFB = mod( jb-1, nb_b )
ibcol  = indxg2p( jb, nb_b, mycol, csrc_b, npcol ),

ICOFFC

PCLARFB()

else if side = 'r',
lwork >= ( nqc0 + max( npv0 + numroc( numroc( n+ICOFFC
mpc0 ) ) * k

PCLARZB()

else if side = 'r',
lwork >= ( nqc0 + max( npv0 + numroc( numroc( n+ICOFFC
mpc0 ) ) * k

PCUNM2L()

if side = 'r', lwork >= nqc0 + max( max( 1, mpc0 ), numroc(
numroc( n+ICOFFC,nb_a,0,0,npcol ),nb_a,0,0,lcmq ) )
where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ),

PCUNM2R()

if side = 'r', lwork >= nqc0 + max( max( 1, mpc0 ), numroc(
numroc( n+ICOFFC,nb_a,0,0,npcol ),nb_a,0,0,lcmq ) )
where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ),

PCUNMBR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PCUNMHR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PCUNML2()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PCUNMLQ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PCUNMQL()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( n+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PCUNMQR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( n+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PCUNMR2()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PCUNMR3()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PCUNMRQ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PCUNMRZ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PCUNMTR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PDLARFB()

else if side = 'r',
lwork >= ( nqc0 + max( npv0 + numroc( numroc( n+ICOFFC
mpc0 ) ) * k

PDLARZB()

else if side = 'r',
lwork >= ( nqc0 + max( npv0 + numroc( numroc( n+ICOFFC
mpc0 ) ) * k

PDORM2L()

if side = 'r', lwork >= nqc0 + max( max( 1, mpc0 ), numroc(
numroc( n+ICOFFC,nb_a,0,0,npcol ),nb_a,0,0,lcmq ) )
where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ),

PDORM2R()

if side = 'r', lwork >= nqc0 + max( max( 1, mpc0 ), numroc(
numroc( n+ICOFFC,nb_a,0,0,npcol ),nb_a,0,0,lcmq ) )
where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ),

PDORMBR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PDORMHR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PDORML2()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PDORMLQ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PDORMQL()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( n+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PDORMQR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( n+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PDORMR2()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PDORMR3()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PDORMRQ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PDORMRZ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PDORMTR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PSLARFB()

else if side = 'r',
lwork >= ( nqc0 + max( npv0 + numroc( numroc( n+ICOFFC
mpc0 ) ) * k

PSLARZB()

else if side = 'r',
lwork >= ( nqc0 + max( npv0 + numroc( numroc( n+ICOFFC
mpc0 ) ) * k

PSORM2L()

if side = 'r', lwork >= nqc0 + max( max( 1, mpc0 ), numroc(
numroc( n+ICOFFC,nb_a,0,0,npcol ),nb_a,0,0,lcmq ) )
where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ),

PSORM2R()

if side = 'r', lwork >= nqc0 + max( max( 1, mpc0 ), numroc(
numroc( n+ICOFFC,nb_a,0,0,npcol ),nb_a,0,0,lcmq ) )
where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ),

PSORMBR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PSORMHR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PSORML2()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PSORMLQ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PSORMQL()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( n+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PSORMQR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( n+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PSORMR2()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PSORMR3()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PSORMRQ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PSORMRZ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PSORMTR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PZLARFB()

else if side = 'r',
lwork >= ( nqc0 + max( npv0 + numroc( numroc( n+ICOFFC
mpc0 ) ) * k

PZLARZB()

else if side = 'r',
lwork >= ( nqc0 + max( npv0 + numroc( numroc( n+ICOFFC
mpc0 ) ) * k

PZUNM2L()

if side = 'r', lwork >= nqc0 + max( max( 1, mpc0 ), numroc(
numroc( n+ICOFFC,nb_a,0,0,npcol ),nb_a,0,0,lcmq ) )
where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ),

PZUNM2R()

if side = 'r', lwork >= nqc0 + max( max( 1, mpc0 ), numroc(
numroc( n+ICOFFC,nb_a,0,0,npcol ),nb_a,0,0,lcmq ) )
where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ),

PZUNMBR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PZUNMHR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PZUNML2()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PZUNMLQ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PZUNMQL()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( n+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PZUNMQR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( n+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

PZUNMR2()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PZUNMR3()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PZUNMRQ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PZUNMRZ()

iroffc = mod( ic-1, mb_c ), ICOFFC = mod( jc-1, nb_c )
iccol = indxg2p( jc, nb_c, mycol, csrc_c, npcol ),

PZUNMTR()

lwork >= max( (nb_a*(nb_a-1))/2, ( nqc0 + max( npa0 +
numroc( numroc( ni+ICOFFC, nb_a, 0, 0, npcol )
nb_a * nb_a

ICOFFC2

PCLARZ()

transpose column vector v (iroffv = ICOFFC2

PCLARZC()

transpose column vector v (iroffv = ICOFFC2

PDLARZ()

transpose column vector v (iroffv = ICOFFC2

PSLARZ()

transpose column vector v (iroffv = ICOFFC2

PZLARZ()

transpose column vector v (iroffv = ICOFFC2

PZLARZC()

transpose column vector v (iroffv = ICOFFC2

ICOFFV

PCLARFB()

iroffv = mod( iv-1, mb_v ), ICOFFV = mod( jv-1, nb_v )
ivcol = indxg2p( jv, nb_v, mycol, csrc_v, npcol ),

PCLARZ()

transpose row vector v (ICOFFV = iroffc2

PCLARZB()

iroffv = mod( iv-1, mb_v ), ICOFFV = mod( jv-1, nb_v )
ivcol = indxg2p( jv, nb_v, mycol, csrc_v, npcol ),

PCLARZC()

transpose row vector v (ICOFFV = iroffc2

PDLARFB()

iroffv = mod( iv-1, mb_v ), ICOFFV = mod( jv-1, nb_v )
ivcol = indxg2p( jv, nb_v, mycol, csrc_v, npcol ),

PDLARZ()

transpose row vector v (ICOFFV = iroffc2

PDLARZB()

iroffv = mod( iv-1, mb_v ), ICOFFV = mod( jv-1, nb_v )
ivcol = indxg2p( jv, nb_v, mycol, csrc_v, npcol ),

PSLARFB()

iroffv = mod( iv-1, mb_v ), ICOFFV = mod( jv-1, nb_v )
ivcol = indxg2p( jv, nb_v, mycol, csrc_v, npcol ),

PSLARZ()

transpose row vector v (ICOFFV = iroffc2

PSLARZB()

iroffv = mod( iv-1, mb_v ), ICOFFV = mod( jv-1, nb_v )
ivcol = indxg2p( jv, nb_v, mycol, csrc_v, npcol ),

PZLARFB()

iroffv = mod( iv-1, mb_v ), ICOFFV = mod( jv-1, nb_v )
ivcol = indxg2p( jv, nb_v, mycol, csrc_v, npcol ),

PZLARZ()

transpose row vector v (ICOFFV = iroffc2

PZLARZB()

iroffv = mod( iv-1, mb_v ), ICOFFV = mod( jv-1, nb_v )
ivcol = indxg2p( jv, nb_v, mycol, csrc_v, npcol ),

PZLARZC()

transpose row vector v (ICOFFV = iroffc2

ICOL1

CLAREF()

ICOL1   (local input/output) intege
undefined on output.

DLAREF()

ICOL1   (local input/output) intege
undefined on output.

PCLAHQR()

(irow1,ICOL1) is (i,j)-coordinates of h(istart,istart

PDLAHQR()

(irow1,ICOL1) is (i,j)-coordinates of h(istart,istart

PSLAHQR()

(irow1,ICOL1) is (i,j)-coordinates of h(istart,istart

PZLAHQR()

(irow1,ICOL1) is (i,j)-coordinates of h(istart,istart

SLAREF()

ICOL1   (local input/output) intege
undefined on output.

ZLAREF()

ICOL1   (local input/output) intege
undefined on output.

ICROW

PCLARF()

send v and tau to the process row ICROW

PCLARFB()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCLARFC()

send v and tau to the process row ICROW

PCLARZB()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCUNM2L()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCUNM2R()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCUNMBR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

PCUNMHR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

PCUNML2()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCUNMLQ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCUNMQL()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCUNMQR()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCUNMR2()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCUNMR3()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCUNMRQ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCUNMRZ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PCUNMTR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

PDLARF()

send v and tau to the process row ICROW

PDLARFB()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDLARZB()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDORM2L()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDORM2R()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDORMBR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

PDORMHR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

PDORML2()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDORMLQ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDORMQL()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDORMQR()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDORMR2()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDORMR3()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDORMRQ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDORMRZ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PDORMTR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

PSLARF()

send v and tau to the process row ICROW

PSLARFB()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSLARZB()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSORM2L()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSORM2R()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSORMBR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

PSORMHR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

PSORML2()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSORMLQ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSORMQL()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSORMQR()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSORMR2()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSORMR3()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSORMRQ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSORMRZ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PSORMTR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

PZLARF()

send v and tau to the process row ICROW

PZLARFB()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZLARFC()

send v and tau to the process row ICROW

PZLARZB()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZUNM2L()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZUNM2R()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZUNMBR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

PZUNMHR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

PZUNML2()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZUNMLQ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZUNMQL()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZUNMQR()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZUNMR2()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZUNMR3()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZUNMRQ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZUNMRZ()

iroffc = mod( ic-1, mb_c ), icoffc = mod( jc-1, nb_c ),
ICROW = indxg2p( ic, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( m+iroffc, mb_c, myrow, icrow, nprow ),

PZUNMTR()

iroffc = mod( icc-1, mb_c ), icoffc = mod( jcc-1, nb_c ),
ICROW = indxg2p( icc, mb_c, myrow, rsrc_c, nprow )
mpc0 = numroc( mi+iroffc, mb_c, myrow, icrow, nprow ),

ICROW2

PCLARZ()

send v and tau to the process row ICROW2

PCLARZC()

send v and tau to the process row ICROW2

PDLARZ()

send v and tau to the process row ICROW2

PSLARZ()

send v and tau to the process row ICROW2

PZLARZ()

send v and tau to the process row ICROW2

PZLARZC()

send v and tau to the process row ICROW2

ICTXT

PCHEEVX()

ICTXT = desca( ctxt_ 
sqnpc = sqrt( dble( nprow * npcol ) )

PCHEGVX()

nq0 = numroc( n, nb, 0, 0, npcol )
ICTXT = desca( ctxt_ 
sqnpc = sqrt( dble( nprow * npcol ) )

PCHENTRD()

lwork >= 2*( anb+1 )*( 4*nps+2 ) + ( nps + 4 ) * nps
ICTXT = desca( ctxt_ 
sqnpc = int( sqrt( real( nprow * npcol ) ) )

PDLABAD()

ICTXT   (global input) intege
place.

PDLAED2()

ICTXT  (global input) intege
the operation on the matrix. the context itself is global.

PDLAED3()

ICTXT  (global input) intege
the operation on the matrix. the context itself is global.

PDLAMCH()

ICTXT   (global input) intege
place.

PDSTEBZ()

ICTXT   (global input) intege

PDSYNTRD()

lwork >= 2*( anb+1 )*( 4*nps+2 ) + ( nps + 4 ) * nps
ICTXT = desca( ctxt_ 
sqnpc = int( sqrt( dble( nprow * npcol ) ) )

PSLABAD()

ICTXT   (global input) intege
place.

PSLAED2()

ICTXT  (global input) intege
the operation on the matrix. the context itself is global.

PSLAED3()

ICTXT  (global input) intege
the operation on the matrix. the context itself is global.

PSLAMCH()

ICTXT   (global input) intege
place.

PSSTEBZ()

ICTXT   (global input) intege

PSSYNTRD()

lwork >= 2*( anb+1 )*( 4*nps+2 ) + ( nps + 4 ) * nps
ICTXT = desca( ctxt_ 
sqnpc = int( sqrt( real( nprow * npcol ) ) )

PZHEEVX()

ICTXT = desca( ctxt_ 
sqnpc = sqrt( dble( nprow * npcol ) )

PZHEGVX()

nq0 = numroc( n, nb, 0, 0, npcol )
ICTXT = desca( ctxt_ 
sqnpc = sqrt( dble( nprow * npcol ) )

PZHENTRD()

lwork >= 2*( anb+1 )*( 4*nps+2 ) + ( nps + 4 ) * nps
ICTXT = desca( ctxt_ 
sqnpc = int( sqrt( dble( nprow * npcol ) ) )

ICURCOL

PCLANHE()

icurrow : process row containing diagonal block
ICURCOL : process column containing diagonal bloc
they are stored along a process column

PCLANSY()

icurrow : process row containing diagonal block
ICURCOL : process column containing diagonal bloc
they are stored along a process column

PDLANSY()

icurrow : process row containing diagonal block
ICURCOL : process column containing diagonal bloc
they are stored along a process column

PSLANSY()

icurrow : process row containing diagonal block
ICURCOL : process column containing diagonal bloc
they are stored along a process column

PZLANHE()

icurrow : process row containing diagonal block
ICURCOL : process column containing diagonal bloc
they are stored along a process column

PZLANSY()

icurrow : process row containing diagonal block
ICURCOL : process column containing diagonal bloc
they are stored along a process column

ICURROW

PCLANHE()

ii, jj  : local indices into array a
ICURROW : process row containing diagonal bloc
irsc0   : pointer to part of work used to store the rowsums while

PCLANSY()

ii, jj  : local indices into array a
ICURROW : process row containing diagonal bloc
irsc0   : pointer to part of work used to store the rowsums while

PDLANSY()

ii, jj  : local indices into array a
ICURROW : process row containing diagonal bloc
irsc0   : pointer to part of work used to store the rowsums while

PSLANSY()

ii, jj  : local indices into array a
ICURROW : process row containing diagonal bloc
irsc0   : pointer to part of work used to store the rowsums while

PZLANHE()

ii, jj  : local indices into array a
ICURROW : process row containing diagonal bloc
irsc0   : pointer to part of work used to store the rowsums while

PZLANSY()

ii, jj  : local indices into array a
ICURROW : process row containing diagonal bloc
irsc0   : pointer to part of work used to store the rowsums while

Ideally

PDSTEBZ()

fudge   double precision, default = 2.0
a "fudge factor" to widen the gershgorin intervals.  Ideally
arithmetic, this needs to be larger.  the default for

PSSTEBZ()

fudge   real, default = 2.0
a "fudge factor" to widen the gershgorin intervals.  Ideally
arithmetic, this needs to be larger.  the default for

identical

PCGBTRF()

is required to make the odd and even frontal matrices
look identical

PCHEEV()

if info = n+1, then pcheev has detected heterogeneity
by finding that eigenvalues were not identical acros
the results from pcheev cannot be guaranteed.

PCHEEVX()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) complex array,

PCHEGVX()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) complex array,

PCSTEIN()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) complex array,

PDGBTRF()

is required to make the odd and even frontal matrices
look identical

PDLAECV()

reltol times the larger (in magnitude) endpoint, or if
the counts at the endpoints are identical to the count
considered to have "converged".

PDLARED1D()

rows and that all process columns contain the same copy of
bycol.  the output array, byall, will be identical on all processe

PDLARED2D()

columns and that all process rows contain the same copy of
byrow.  the output array, byall, will be identical on all processe

PDSTEIN()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) double precision array,

PDSYEV()

if info = n+1, then pdsyev has detected heterogeneity
by finding that eigenvalues were not identical acros
the results from pdsyev cannot be guaranteed.

PDSYEVX()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) double precision array,

PDSYGVX()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) double precision array,

PJLAENV()

most parameters set via a call to pjlaenv must be identical
value to all procesors (i.e. global output).  however some,

PSGBTRF()

is required to make the odd and even frontal matrices
look identical

PSLAECV()

reltol times the larger (in magnitude) endpoint, or if
the counts at the endpoints are identical to the count
considered to have "converged".

PSLARED1D()

rows and that all process columns contain the same copy of
bycol.  the output array, byall, will be identical on all processe

PSLARED2D()

columns and that all process rows contain the same copy of
byrow.  the output array, byall, will be identical on all processe

PSSTEIN()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) real array,

PSSYEV()

if info = n+1, then pssyev has detected heterogeneity
by finding that eigenvalues were not identical acros
the results from pssyev cannot be guaranteed.

PSSYEVX()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) real array,

PSSYGVX()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) real array,

PZGBTRF()

is required to make the odd and even frontal matrices
look identical

PZHEEV()

if info = n+1, then pzheev has detected heterogeneity
by finding that eigenvalues were not identical acros
the results from pzheev cannot be guaranteed.

PZHEEVX()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) complex*16 array,

PZHEGVX()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) complex*16 array,

PZSTEIN()

a default value of 10^-3 is used if orfac is negative.
orfac should be identical on all processes
z       (local output) complex*16 array,

identified

PDSTEBZ()

does not converge for some or all eigenvalues, info is set
to 1 and the ones for which it did not are identified by 

PSSTEBZ()

does not converge for some or all eigenvalues, info is set
to 1 and the ones for which it did not are identified by 

identify

PDLABAD()

the log of large is sufficiently large.  this subroutine is intended
to identify machines with a large exponent range, such as the crays
of the values computed by pdlamch.  this subroutine is needed because

PSLABAD()

the log of large is sufficiently large.  this subroutine is intended
to identify machines with a large exponent range, such as the crays
of the values computed by pslamch.  this subroutine is needed because

IEEE

PCHEEVX()

pcheevx assumes IEEE 754 standard compliant arithmetic.  to por
the appropriate slmake.inc file to include the compiler switch

PDLAEBZ()

a flag which indicates whether n(w) should be speeded up by
exploiting IEEE arithmetic
info    (output) integer

PDSTEBZ()

note : it is assumed that the user is on an IEEE machine. if the use
to 1 (in slmake.inc). the features of ieee arithmetic that

PDSYEVX()

pdsyevx assumes IEEE 754 standard compliant arithmetic.  to por
the appropriate slmake.inc file to include the compiler switch

PSLAEBZ()

a flag which indicates whether n(w) should be speeded up by
exploiting IEEE arithmetic
info    (output) integer

PSSTEBZ()

note : it is assumed that the user is on an IEEE machine. if the use
to 1 (in slmake.inc). the features of ieee arithmetic that

PSSYEVX()

pssyevx assumes IEEE 754 standard compliant arithmetic.  to por
the appropriate slmake.inc file to include the compiler switch

PZHEEVX()

pzheevx assumes IEEE 754 standard compliant arithmetic.  to por
the appropriate slmake.inc file to include the compiler switch

IEFLAG

PDLAEBZ()

IEFLAG  (input) intege
exploiting ieee arithmetic.

PSLAEBZ()

IEFLAG  (input) intege
exploiting ieee arithmetic.

IFAIL

DSTEIN2()

if stopping criterion was not satisfied, update info and
store eigenvector number in array IFAIL

PCHEEVX()

approximation to the eigenvector, and the index of the
eigenvector is returned in IFAIL

PCHEGVX()

approximation to the eigenvector, and the index of the
eigenvector is returned in IFAIL

PCSTEIN()

IFAIL   (global output) integer array, dimension (m
if one or more eigenvectors fail to converge after maxits

PDSTEIN()

IFAIL   (global output) integer array, dimension (m
if one or more eigenvectors fail to converge after maxits

PDSYEVX()

approximation to the eigenvector, and the index of the
eigenvector is returned in IFAIL

PDSYGVX()

approximation to the eigenvector, and the index of the
eigenvector is returned in IFAIL

PSSTEIN()

IFAIL   (global output) integer array, dimension (m
if one or more eigenvectors fail to converge after maxits

PSSYEVX()

approximation to the eigenvector, and the index of the
eigenvector is returned in IFAIL

PSSYGVX()

approximation to the eigenvector, and the index of the
eigenvector is returned in IFAIL

PZHEEVX()

approximation to the eigenvector, and the index of the
eigenvector is returned in IFAIL

PZHEGVX()

approximation to the eigenvector, and the index of the
eigenvector is returned in IFAIL

PZSTEIN()

IFAIL   (global output) integer array, dimension (m
if one or more eigenvectors fail to converge after maxits

SSTEIN2()

if stopping criterion was not satisfied, update info and
store eigenvector number in array IFAIL

Ignored

CLAREF()

used as an index into vecs if block is set.
istart is Ignored if block is .false.
istop   (global input) integer

DLAREF()

used as an index into vecs if block is set.
istart is Ignored if block is .false.
istop   (global input) integer

PCDTSV()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PCDTTRS()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PCLAMR1D()

i am not sure that this works correctly when ib and jb are not equal
to 1.  indeed, i suspect that ib should always be set to 1 or Ignored

PCPTSV()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PCPTTRS()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PDDTSV()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PDDTTRS()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PDLAMR1D()

i am not sure that this works correctly when ib and jb are not equal
to 1.  indeed, i suspect that ib should always be set to 1 or Ignored

PDPTSV()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PDPTTRS()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PSDTSV()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PSDTTRS()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PSLAMR1D()

i am not sure that this works correctly when ib and jb are not equal
to 1.  indeed, i suspect that ib should always be set to 1 or Ignored

PSPTSV()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PSPTTRS()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PZDTSV()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PZDTTRS()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PZLAMR1D()

i am not sure that this works correctly when ib and jb are not equal
to 1.  indeed, i suspect that ib should always be set to 1 or Ignored

PZPTSV()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

PZPTTRS()

is distributed.
Ignored         desca( 6 ) ignored for tridiagonal matrices

SLAREF()

used as an index into vecs if block is set.
istart is Ignored if block is .false.
istop   (global input) integer

ZLAREF()

used as an index into vecs if block is set.
istart is Ignored if block is .false.
istop   (global input) integer

IHI

CLAHQR2()

the main loop begins here. i is the loop index and decreases from
IHI to ilo in steps of 1 or 2. each iteration of the loop work
eigenvalues i+1 to ihi have already converged. either l = ilo, or

PCGEHD2()

ilo     (global input) integer
IHI     (global input) intege
rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+jlo-2

PCGEHRD()

ilo     (global input) integer
IHI     (global input) intege
rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+ilo-2

PCLAHQR()

the main loop begins here. i is the loop index and decreases from
IHI to ilo in steps of our schur block size (<=2*iblk). eac
and columns l to i.   eigenvalues i+1 to ihi have already

PCUNMHR()

nq = m if side = 'l' and nq = n if side = 'r'. q is defined as the
product of IHI-ilo elementary reflectors, as returned by pcgehrd
q = h(ilo) h(ilo+1) . . . h(ihi-1).

PDGEHD2()

ilo     (global input) integer
IHI     (global input) intege
rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+jlo-2

PDGEHRD()

ilo     (global input) integer
IHI     (global input) intege
rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+ilo-2

PDLAHQR()

the main loop begins here. i is the loop index and decreases from
IHI to ilo in steps of our schur block size (<=2*iblk). eac
and columns l to i.   eigenvalues i+1 to ihi have already

PDORMHR()

nq = m if side = 'l' and nq = n if side = 'r'. q is defined as the
product of IHI-ilo elementary reflectors, as returned by pdgehrd
q = h(ilo) h(ilo+1) . . . h(ihi-1).

PSGEHD2()

ilo     (global input) integer
IHI     (global input) intege
rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+jlo-2

PSGEHRD()

ilo     (global input) integer
IHI     (global input) intege
rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+ilo-2

PSLAHQR()

the main loop begins here. i is the loop index and decreases from
IHI to ilo in steps of our schur block size (<=2*iblk). eac
and columns l to i.   eigenvalues i+1 to ihi have already

PSORMHR()

nq = m if side = 'l' and nq = n if side = 'r'. q is defined as the
product of IHI-ilo elementary reflectors, as returned by psgehrd
q = h(ilo) h(ilo+1) . . . h(ihi-1).

PZGEHD2()

ilo     (global input) integer
IHI     (global input) intege
rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+jlo-2

PZGEHRD()

ilo     (global input) integer
IHI     (global input) intege
rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+ilo-2

PZLAHQR()

the main loop begins here. i is the loop index and decreases from
IHI to ilo in steps of our schur block size (<=2*iblk). eac
and columns l to i.   eigenvalues i+1 to ihi have already

PZUNMHR()

nq = m if side = 'l' and nq = n if side = 'r'. q is defined as the
product of IHI-ilo elementary reflectors, as returned by pzgehrd
q = h(ilo) h(ilo+1) . . . h(ihi-1).

ZLAHQR2()

the main loop begins here. i is the loop index and decreases from
IHI to ilo in steps of 1 or 2. each iteration of the loop work
eigenvalues i+1 to ihi have already converged. either l = ilo, or

IHIP

PCGEHRD()

lwork is local input and must be at least
lwork >= nb*nb + nb*max( IHIP+1, ihlp+inlq 
where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),

PDGEHRD()

lwork is local input and must be at least
lwork >= nb*nb + nb*max( IHIP+1, ihlp+inlq 
where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),

PSGEHRD()

lwork is local input and must be at least
lwork >= nb*nb + nb*max( IHIP+1, ihlp+inlq 
where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),

PZGEHRD()

lwork is local input and must be at least
lwork >= nb*nb + nb*max( IHIP+1, ihlp+inlq 
where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),

IHLP

PCGEHRD()

lwork is local input and must be at least
lwork >= nb*nb + nb*max( ihip+1, IHLP+inlq 
where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),

PDGEHRD()

lwork is local input and must be at least
lwork >= nb*nb + nb*max( ihip+1, IHLP+inlq 
where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),

PSGEHRD()

lwork is local input and must be at least
lwork >= nb*nb + nb*max( ihip+1, IHLP+inlq 
where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),

PZGEHRD()

lwork is local input and must be at least
lwork >= nb*nb + nb*max( ihip+1, IHLP+inlq 
where nb = mb_a = nb_a, iroffa = mod( ia-1, nb ),

IJOB

PDLAEBZ()

IJOB    (input) intege
= 0 : find an interval with desired values of n(w) at the

PDLAECV()

IJOB    (input) intege
= 0 : when an interval is narrower than abstol, or than

PSLAEBZ()

IJOB    (input) intege
= 0 : find an interval with desired values of n(w) at the

PSLAECV()

IJOB    (input) intege
= 0 : when an interval is narrower than abstol, or than

ILAENV

PJLAENV()

pjlaenv is patterned after ILAENV and keeps the same interface i
used at present in scalapack.  most scalapack codes use the input

ILCM

PCGELS()

where lcmp = lcm / nprow with lcm = ILCM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PCLARFB()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCLARZB()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNM2L()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNM2R()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNMHR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNML2()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNMLQ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNMQL()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNMQR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNMR2()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNMR3()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNMRQ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNMRZ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PCUNMTR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDGELS()

where lcmp = lcm / nprow with lcm = ILCM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PDLARFB()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDLARZB()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORM2L()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORM2R()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORMHR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORML2()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORMLQ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORMQL()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORMQR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORMR2()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORMR3()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORMRQ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORMRZ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PDORMTR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSGELS()

where lcmp = lcm / nprow with lcm = ILCM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PSLARFB()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSLARZB()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORM2L()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORM2R()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORMHR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORML2()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORMLQ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORMQL()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORMQR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORMR2()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORMR3()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORMRQ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORMRZ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PSORMTR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZGELS()

where lcmp = lcm / nprow with lcm = ILCM( nprow, npcol )
iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ),

PZLARFB()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZLARZB()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNM2L()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNM2R()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNMHR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNML2()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNMLQ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNMQL()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNMQR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNMR2()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNMR3()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNMRQ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNMRZ()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

PZUNMTR()

ILCM, indxg2p and numroc are scalapack tool functions
the subroutine blacs_gridinfo.

ILCOL

PCGEHRD()

ihlp = numroc( ihi-ilo+ioff+1, nb, myrow, ilrow, nprow ),
ILCOL = indxg2p( ja+ilo-1, nb, mycol, csrc_a, npcol )

PDGEHRD()

ihlp = numroc( ihi-ilo+ioff+1, nb, myrow, ilrow, nprow ),
ILCOL = indxg2p( ja+ilo-1, nb, mycol, csrc_a, npcol )

PSGEHRD()

ihlp = numroc( ihi-ilo+ioff+1, nb, myrow, ilrow, nprow ),
ILCOL = indxg2p( ja+ilo-1, nb, mycol, csrc_a, npcol )

PZGEHRD()

ihlp = numroc( ihi-ilo+ioff+1, nb, myrow, ilrow, nprow ),
ILCOL = indxg2p( ja+ilo-1, nb, mycol, csrc_a, npcol )

illegal

CDBTF2()

= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal valu
has been completed, but the factor u is exactly

CDTTRF()

= 0:  successful exit
< 0:  if info = -i, the i-th argument had an illegal valu
has been completed, but the factor u is exactly

CDTTRSV()

= 0:  successful exit
< 0:  if info = -i, the i-th argument had an illegal valu
=====================================================================

CPTTRSV()

= 0:  successful exit
< 0:  if info = -i, the i-th argument had an illegal valu
=====================================================================

DDBTF2()

= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal valu
has been completed, but the factor u is exactly

DDTTRF()

= 0:  successful exit
< 0:  if info = -i, the i-th argument had an illegal valu
has been completed, but the factor u is exactly

DDTTRSV()

= 0:  successful exit
< 0:  if info = -i, the i-th argument had an illegal valu
=====================================================================

DPTTRSV()

= 0:  successful exit
< 0:  if info = -i, the i-th argument had an illegal valu
=====================================================================

PCDBSV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCDBTRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCDTSV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCDTTRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGBSV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGBTRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGEBD2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGEBRD()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGECON()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGEEQU()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGEHD2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGEHRD()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGELQ2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGELQF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGELS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGEQL2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGEQLF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGEQPF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGEQR2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGEQRF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGERFS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGERQ2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGERQF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGESV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGESVD()

= 0:  successful exit
< 0:  if info = -i, the i-th argument had an illegal valu

PCGESVX()

= 0:  successful exit
< 0:  if info = -i, the i-th argument had an illegal valu
<= n:  u(ia+i-1,ia+i-1) is exactly zero.  the

PCGETF2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGETRF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGETRI()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGETRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGGQRF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCGGRQF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCHEEV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCHEEVD()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCHEEVX()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCHEGS2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCHEGST()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCHEGVX()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCHENGST()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCHENTRD()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCHETD2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCHETRD()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCHETTRD()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCLASCL()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPBSV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPBTRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPOCON()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPOEQU()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPORFS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPOSV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPOSVX()

= 0: successful exit
< 0: if info = -i, the i-th argument had an illegal valu
<= n: if info = i, the leading minor of order i of a

PCPOTF2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPOTRF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPOTRI()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPOTRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPTSV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCPTTRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCSTEIN()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCTRCON()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCTREVC()

= 0:  successful exit
< 0:  if info = -i, the i-th argument had an illegal valu
further details

PCTRRFS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCTRTI2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCTRTRI()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCTRTRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCTZRZF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNG2L()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNG2R()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNGL2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNGLQ()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNGQL()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNGQR()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNGR2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNGRQ()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNM2L()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNM2R()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNMBR()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNMHR()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNML2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNMLQ()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNMQL()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNMQR()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNMR2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNMR3()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNMRQ()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNMRZ()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PCUNMTR()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDDBSV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDDBTRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDDTSV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDDTTRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGBSV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGBTRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGEBD2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGEBRD()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGECON()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGEEQU()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGEHD2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGEHRD()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGELQ2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGELQF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGELS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGEQL2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGEQLF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGEQPF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGEQR2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGEQRF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGERFS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGERQ2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGERQF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGESV()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGESVD()

= 0:  successful exit
< 0:  if info = -i, the i-th argument had an illegal valu

PDGESVX()

= 0:  successful exit
< 0:  if info = -i, the i-th argument had an illegal valu
<= n:  u(ia+i-1,ia+i-1) is exactly zero.  the

PDGETF2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGETRF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGETRI()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGETRS()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGGQRF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDGGRQF()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDLAED0()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDLAED1()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDLAED3()

= 0:  successful exit.
< 0:  if info = -i, the i-th argument had an illegal value

PDLASCL()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDLASRT()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORG2L()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORG2R()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORGL2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORGLQ()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORGQL()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORGQR()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORGR2()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORGRQ()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORM2L()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORM2R()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORMBR()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.

PDORMHR()

< 0:  if the i-th argument is an array and the j-entry had
an illegal value, then info = -(i*100+j), if the i-t
info = -i.