QBUF

PDLAED2()

QBUF   (workspace) double precision array, dimension 3*
ctot   (workspace) integer array, dimension( npcol, 4)

PDLAED3()

QBUF   (workspace) double precision array, dimension 3*

PSLAED2()

QBUF   (workspace) real array, dimension 3*
ctot   (workspace) integer array, dimension( npcol, 4)

PSLAED3()

QBUF   (workspace) real array, dimension 3*

QLN

PCGESVD()

max(wcbdsqr,
max(wantu*wpcormbrQLN, wantvt*wpcormbrprt))
where

PDGESVD()

max(wdbdsqr,
max(wantu*wpdormbrQLN, wantvt*wpdormbrprt))
where

PSGESVD()

max(wsbdsqr,
max(wantu*wpsormbrQLN, wantvt*wpsormbrprt))
where

PZGESVD()

max(wzbdsqr,
max(wantu*wpzormbrQLN, wantvt*wpzormbrprt))
where

QRMEM

PDSYEV()

QRMEM = 2*n-

PSSYEV()

QRMEM = 2*n-

quality

PCPOSVX()

of the largest entry in (x(j) - xtrue) divided by
the magnitude of the largest entry in x(j).  the quality o
norm(inv(a)) computed in the code; if the estimate of

PDPOSVX()

of the largest entry in (x(j) - xtrue) divided by
the magnitude of the largest entry in x(j).  the quality o
norm(inv(a)) computed in the code; if the estimate of

PSPOSVX()

of the largest entry in (x(j) - xtrue) divided by
the magnitude of the largest entry in x(j).  the quality o
norm(inv(a)) computed in the code; if the estimate of

PZPOSVX()

of the largest entry in (x(j) - xtrue) divided by
the magnitude of the largest entry in x(j).  the quality o
norm(inv(a)) computed in the code; if the estimate of

quantities

PCDBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCDBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCDTSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCDTTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGEBD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGEBRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGECON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGEEQU()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGEHD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGEHRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGELQ2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGELQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGELS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGEQL2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGEQLF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGEQPF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGEQR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGEQRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGERFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGERQ2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGERQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGESV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGESVD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGESVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGETF2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGETRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGETRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGETRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGGQRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCGGRQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCHEEVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCHEGS2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCHEGST()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCHEGVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCHENGST()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCHENTRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCHETD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCHETRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCHETTRD()

locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locq( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLABRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLACGV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLACON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLACONSB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLACP2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLACP3()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLACPY()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLAEVSWP()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLANGE()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLAPIV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLAPV2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLAQGE()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLAQSY()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLARFB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLARFG()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLARFT()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLARZB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLARZT()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLASCL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLASE2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLASET()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLASMSUB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLASSQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLASWP()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLATRA()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLATRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLATRZ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLAUU2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLAUUM()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCLAWIL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCMAX1()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPOCON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPOEQU()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPORFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPOSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPOSVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPOTF2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPOTRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPOTRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPOTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPTSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCPTTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCSRSCL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCSTEIN()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCTRCON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCTREVC()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCTRRFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCTRTI2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCTRTRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCTRTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCTZRZF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNG2L()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNG2R()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNGL2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNGLQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNGQL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNGQR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNGR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNGRQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNM2L()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNM2R()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNMBR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNMHR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNML2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNMLQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNMQL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNMQR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNMR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNMR3()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNMRQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNMRZ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PCUNMTR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDDBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDDBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDDTSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDDTTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGEBD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGEBRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGECON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGEEQU()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGEHD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGEHRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGELQ2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGELQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGELS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGEQL2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGEQLF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGEQPF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGEQR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGEQRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGERFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGERQ2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGERQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGESV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGESVD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGESVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGETF2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGETRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGETRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGETRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGGQRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDGGRQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLABRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLACON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLACONSB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLACP2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLACP3()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLACPY()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLAEVSWP()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLANGE()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLAPIV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLAPV2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLAQGE()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLAQSY()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLARED1D()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLARED2D()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLARFB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLARFG()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLARFT()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLARZB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLARZT()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLASCL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLASE2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLASET()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLASMSUB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLASSQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLASWP()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLATRA()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLATRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLATRZ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLAUU2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLAUUM()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDLAWIL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORG2L()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORG2R()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORGL2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORGLQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORGQL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORGQR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORGR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORGRQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORM2L()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORM2R()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORMBR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORMHR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORML2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORMLQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORMQL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORMQR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORMR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORMR3()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORMRQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORMRZ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDORMTR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPOCON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPOEQU()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPORFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPOSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPOSVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPOTF2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPOTRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPOTRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPOTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPTSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDPTTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDRSCL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDSTEIN()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDSYEVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDSYGS2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDSYGST()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDSYGVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDSYNGST()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDSYNTRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDSYTD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDSYTRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDSYTTRD()

locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locq( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDTRCON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDTRRFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDTRTI2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDTRTRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDTRTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDTZRZF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PDZSUM1()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSCSUM1()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSDBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSDBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSDTSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSDTTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGEBD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGEBRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGECON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGEEQU()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGEHD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGEHRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGELQ2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGELQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGELS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGEQL2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGEQLF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGEQPF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGEQR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGEQRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGERFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGERQ2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGERQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGESV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGESVD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGESVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGETF2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGETRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGETRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGETRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGGQRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSGGRQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLABRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLACON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLACONSB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLACP2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLACP3()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLACPY()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLAEVSWP()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLANGE()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLAPIV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLAPV2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLAQGE()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLAQSY()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLARED1D()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLARED2D()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLARFB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLARFG()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLARFT()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLARZB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLARZT()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLASCL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLASE2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLASET()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLASMSUB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLASSQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLASWP()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLATRA()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLATRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLATRZ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLAUU2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLAUUM()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSLAWIL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORG2L()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORG2R()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORGL2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORGLQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORGQL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORGQR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORGR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORGRQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORM2L()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORM2R()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORMBR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORMHR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORML2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORMLQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORMQL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORMQR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORMR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORMR3()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORMRQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORMRZ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSORMTR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPOCON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPOEQU()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPORFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPOSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPOSVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPOTF2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPOTRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPOTRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPOTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPTSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSPTTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSRSCL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSSTEIN()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSSYEVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSSYGS2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSSYGST()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSSYGVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSSYNGST()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSSYNTRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSSYTD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSSYTRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSSYTTRD()

locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locq( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSTRCON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSTRRFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSTRTI2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSTRTRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSTRTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PSTZRZF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZDBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZDBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZDRSCL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZDTSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZDTTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGEBD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGEBRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGECON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGEEQU()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGEHD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGEHRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGELQ2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGELQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGELS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGEQL2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGEQLF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGEQPF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGEQR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGEQRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGERFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGERQ2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGERQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGESV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGESVD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGESVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGETF2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGETRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGETRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGETRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGGQRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZGGRQF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZHEEVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZHEGS2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZHEGST()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZHEGVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZHENGST()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZHENTRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZHETD2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZHETRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZHETTRD()

locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locq( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLABRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLACGV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLACON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLACONSB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLACP2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLACP3()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLACPY()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLAEVSWP()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLANGE()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLAPIV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLAPV2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLAQGE()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLAQSY()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLARFB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLARFG()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLARFT()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLARZB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLARZT()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLASCL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLASE2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLASET()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLASMSUB()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLASSQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLASWP()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLATRA()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLATRD()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLATRZ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLAUU2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLAUUM()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZLAWIL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZMAX1()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPBSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPBTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPOCON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPOEQU()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPORFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPOSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPOSVX()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPOTF2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPOTRF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPOTRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPOTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPTSV()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZPTTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZSTEIN()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZTRCON()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZTREVC()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZTRRFS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZTRTI2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZTRTRI()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZTRTRS()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZTZRZF()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNG2L()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNG2R()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNGL2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNGLQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNGQL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNGQR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNGR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNGRQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNM2L()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNM2R()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNMBR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNMHR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNML2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNMLQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNMQL()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNMQR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNMR2()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNMR3()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNMRQ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNMRZ()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

PZUNMTR()

locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ).
an upper bound for these quantities may be computed by
locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a

query

PCGEBD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGEBRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGECON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGEHD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGEHRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGELQ2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGELQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGELS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGEQL2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGEQLF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGEQPF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGEQR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGEQRF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGERFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGERQ2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGERQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGESVD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PCGESVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGETRI()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGGQRF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCGGRQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCHEEV()

if lwork = -1, the lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PCHEEVD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine calculates the size for al
entry of the corresponding work array, and no error message

PCHEEVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates th
values is returned in the first entry of the corresponding

PCHEGVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the optima
in the first entry of the correspondingwork array, and no

PCHENGST()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates th
values is returned in the first entry of the corresponding

PCHETD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCHETRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCPOCON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCPORFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCPOSVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCSTEIN()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCTRCON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCTRRFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCTZRZF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNG2L()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNG2R()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNGL2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNGLQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNGQL()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNGQR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNGR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNGRQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNM2L()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNM2R()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNMBR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNMHR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNML2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNMLQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNMQL()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNMQR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNMR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNMR3()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNMRQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNMRZ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PCUNMTR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGEBD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGEBRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGECON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGEHD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGEHRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGELQ2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGELQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGELS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGEQL2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGEQLF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGEQPF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGEQR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGEQRF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGERFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGERQ2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGERQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGESVD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PDGESVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGETRI()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGGQRF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDGGRQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORG2L()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORG2R()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORGL2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORGLQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORGQL()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORGQR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORGR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORGRQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORM2L()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORM2R()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORMBR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORMHR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORML2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORMLQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORMQL()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORMQR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORMR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORMR3()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORMRQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORMRZ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDORMTR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDPOCON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDPORFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDPOSVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDSTEBZ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDSTEDC()

if lwork = -1, the lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PDSTEIN()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDSYEV()

if lwork = -1, the lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PDSYEVD()

if lwork = -1, the lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PDSYEVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the siz
these values is returned in the first entry of the

PDSYGVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the siz
each of these values is returned in the first entry of the

PDSYNGST()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates th
values is returned in the first entry of the corresponding

PDSYTD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDSYTRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDTRCON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDTRRFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PDTZRZF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGEBD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGEBRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGECON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGEHD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGEHRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGELQ2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGELQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGELS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGEQL2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGEQLF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGEQPF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGEQR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGEQRF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGERFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGERQ2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGERQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGESVD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PSGESVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGETRI()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGGQRF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSGGRQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORG2L()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORG2R()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORGL2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORGLQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORGQL()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORGQR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORGR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORGRQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORM2L()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORM2R()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORMBR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORMHR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORML2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORMLQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORMQL()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORMQR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORMR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORMR3()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORMRQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORMRZ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSORMTR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSPOCON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSPORFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSPOSVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSSTEBZ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSSTEDC()

if lwork = -1, the lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PSSTEIN()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSSYEV()

if lwork = -1, the lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PSSYEVD()

if lwork = -1, the lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PSSYEVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the siz
these values is returned in the first entry of the

PSSYGVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the siz
each of these values is returned in the first entry of the

PSSYNGST()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates th
values is returned in the first entry of the corresponding

PSSYTD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSSYTRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSTRCON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSTRRFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PSTZRZF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGEBD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGEBRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGECON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGEHD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGEHRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGELQ2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGELQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGELS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGEQL2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGEQLF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGEQPF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGEQR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGEQRF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGERFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGERQ2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGERQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGESVD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PZGESVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGETRI()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGGQRF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZGGRQF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZHEEV()

if lwork = -1, the lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
as the first element of work and no error message is issued

PZHEEVD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine calculates the size for al
entry of the corresponding work array, and no error message

PZHEEVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates th
values is returned in the first entry of the corresponding

PZHEGVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the optima
in the first entry of the correspondingwork array, and no

PZHENGST()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates th
values is returned in the first entry of the corresponding

PZHETD2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZHETRD()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZPOCON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZPORFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZPOSVX()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZSTEIN()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZTRCON()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZTRRFS()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZTZRZF()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNG2L()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNG2R()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNGL2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNGLQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNGQL()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNGQR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNGR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNGRQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNM2L()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNM2R()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNMBR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNMHR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNML2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNMLQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNMQL()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNMQR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNMR2()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNMR3()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNMRQ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNMRZ()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

PZUNMTR()

if lwork = -1, then lwork is global input and a workspace
query is assumed; the routine only calculates the minimu
values is returned in the first entry of the corresponding

Quick

CDBTRF()

Quick return if possibl

CLAHQR2()

Quick return if possibl

DDBTRF()

Quick return if possibl

DLAPST()

Quick return if possibl

DLASRT2()

Quick return if possibl

DSTEIN2()

Quick return if possibl

DSTEQR2()

Quick return if possibl

PCDBTRF()

Quick return if possibl

PCDBTRSV()

Quick return if possibl

PCDTTRF()

Quick return if possibl

PCDTTRSV()

Quick return if possibl

PCGBTRF()

Quick return if possibl

PCLARF()

Quick return if possibl

PCLARFC()

Quick return if possibl

PCLARZ()

Quick return if possibl

PCLARZC()

Quick return if possibl

PCLATRS()

Quick return if possibl

PCLATTRS()

Quick return if possibl

PCPBTRF()

Quick return if possibl

PCPBTRSV()

Quick return if possibl

PCPTTRF()

Quick return if possibl

PCPTTRSV()

Quick return if possibl

PDDBTRF()

Quick return if possibl

PDDBTRSV()

Quick return if possibl

PDDTTRF()

Quick return if possibl

PDDTTRSV()

Quick return if possibl

PDGBTRF()

Quick return if possibl

PDLARF()

Quick return if possibl

PDLARZ()

Quick return if possibl

PDLATRS()

Quick return if possibl

PDPBTRF()

Quick return if possibl

PDPBTRSV()

Quick return if possibl

PDPTTRF()

Quick return if possibl

PDPTTRSV()

Quick return if possibl

PSDBTRF()

Quick return if possibl

PSDBTRSV()

Quick return if possibl

PSDTTRF()

Quick return if possibl

PSDTTRSV()

Quick return if possibl

PSGBTRF()

Quick return if possibl

PSLARF()

Quick return if possibl

PSLARZ()

Quick return if possibl

PSLATRS()

Quick return if possibl

PSPBTRF()

Quick return if possibl

PSPBTRSV()

Quick return if possibl

PSPTTRF()

Quick return if possibl

PSPTTRSV()

Quick return if possibl

PZDBTRF()

Quick return if possibl

PZDBTRSV()

Quick return if possibl

PZDTTRF()

Quick return if possibl

PZDTTRSV()

Quick return if possibl

PZGBTRF()

Quick return if possibl

PZLARF()

Quick return if possibl

PZLARFC()

Quick return if possibl

PZLARZ()

Quick return if possibl

PZLARZC()

Quick return if possibl

PZLATRS()

Quick return if possibl

PZLATTRS()

Quick return if possibl

PZPBTRF()

Quick return if possibl

PZPBTRSV()

Quick return if possibl

PZPTTRF()

Quick return if possibl

PZPTTRSV()

Quick return if possibl

SDBTRF()

Quick return if possibl

SLAPST()

Quick return if possibl

SLASRT2()

Quick return if possibl

SSTEIN2()

Quick return if possibl

SSTEQR2()

Quick return if possibl

ZDBTRF()

Quick return if possibl

ZLAHQR2()

Quick return if possibl

quit

PDLAEBZ()

more than mmax intervals are generated, then pdlaebz will
quit with info = mmax+1
minp    (input) integer

PSLAEBZ()

more than mmax intervals are generated, then pslaebz will
quit with info = mmax+1
minp    (input) integer