object

PCDBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCDBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCDTSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCDTTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGEBD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGEBRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGECON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGEEQU()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGEHD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGEHRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGELQ2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGELQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGELS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGEQL2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGEQLF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGEQPF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGEQR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGEQRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGERFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGERQ2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGERQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGESV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGESVD()

=====
each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGESVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGETF2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGETRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGETRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGETRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGGQRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCGGRQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCHEEVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCHEGS2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCHEGST()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCHEGVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCHENGST()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCHENTRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCHETD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCHETRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCHETTRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding

PCLABRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLACGV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLACON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLACONSB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLACP2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLACP3()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLACPY()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLAEVSWP()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLANGE()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLAPIV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLAPV2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLAQGE()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLAQSY()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLARFB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLARFG()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLARFT()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLARZB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLARZT()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLASCL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLASE2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLASET()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLASMSUB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLASSQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLASWP()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLATRA()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLATRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLATRZ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLAUU2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLAUUM()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCLAWIL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCMAX1()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPOCON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPOEQU()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPORFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPOSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPOSVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPOTF2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPOTRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPOTRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPOTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPTSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCPTTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCSRSCL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCSTEIN()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCTRCON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCTREVC()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCTRRFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCTRTI2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCTRTRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCTRTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCTZRZF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNG2L()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNG2R()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNGL2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNGLQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNGQL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNGQR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNGR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNGRQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNM2L()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNM2R()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNMBR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNMHR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNML2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNMLQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNMQL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNMQR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNMR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNMR3()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNMRQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNMRZ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PCUNMTR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDDBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDDBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDDTSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDDTTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGEBD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGEBRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGECON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGEEQU()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGEHD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGEHRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGELQ2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGELQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGELS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGEQL2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGEQLF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGEQPF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGEQR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGEQRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGERFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGERQ2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGERQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGESV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGESVD()

=====
each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGESVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGETF2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGETRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGETRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGETRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGGQRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDGGRQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLABRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLACON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLACONSB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLACP2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLACP3()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLACPY()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLAEVSWP()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLANGE()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLAPIV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLAPV2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLAQGE()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLAQSY()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLARED1D()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLARED2D()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLARFB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLARFG()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLARFT()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLARZB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLARZT()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLASCL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLASE2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLASET()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLASMSUB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLASSQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLASWP()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLATRA()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLATRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLATRZ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLAUU2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLAUUM()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDLAWIL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORG2L()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORG2R()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORGL2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORGLQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORGQL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORGQR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORGR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORGRQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORM2L()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORM2R()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORMBR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORMHR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORML2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORMLQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORMQL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORMQR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORMR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORMR3()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORMRQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORMRZ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDORMTR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPOCON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPOEQU()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPORFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPOSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPOSVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPOTF2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPOTRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPOTRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPOTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPTSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDPTTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDRSCL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDSTEIN()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDSYEVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDSYGS2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDSYGST()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDSYGVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDSYNGST()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDSYNTRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDSYTD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDSYTRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDSYTTRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding

PDTRCON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDTRRFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDTRTI2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDTRTRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDTRTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDTZRZF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PDZSUM1()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSCSUM1()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSDBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSDBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSDTSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSDTTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGEBD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGEBRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGECON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGEEQU()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGEHD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGEHRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGELQ2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGELQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGELS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGEQL2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGEQLF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGEQPF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGEQR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGEQRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGERFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGERQ2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGERQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGESV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGESVD()

=====
each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGESVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGETF2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGETRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGETRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGETRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGGQRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSGGRQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLABRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLACON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLACONSB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLACP2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLACP3()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLACPY()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLAEVSWP()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLANGE()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLAPIV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLAPV2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLAQGE()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLAQSY()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLARED1D()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLARED2D()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLARFB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLARFG()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLARFT()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLARZB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLARZT()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLASCL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLASE2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLASET()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLASMSUB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLASSQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLASWP()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLATRA()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLATRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLATRZ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLAUU2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLAUUM()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSLAWIL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORG2L()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORG2R()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORGL2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORGLQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORGQL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORGQR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORGR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORGRQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORM2L()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORM2R()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORMBR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORMHR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORML2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORMLQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORMQL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORMQR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORMR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORMR3()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORMRQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORMRZ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSORMTR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPOCON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPOEQU()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPORFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPOSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPOSVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPOTF2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPOTRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPOTRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPOTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPTSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSPTTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSRSCL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSSTEIN()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSSYEVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSSYGS2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSSYGST()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSSYGVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSSYNGST()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSSYNTRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSSYTD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSSYTRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSSYTTRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding

PSTRCON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSTRRFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSTRTI2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSTRTRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSTRTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PSTZRZF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZDBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZDBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZDRSCL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZDTSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZDTTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGEBD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGEBRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGECON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGEEQU()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGEHD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGEHRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGELQ2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGELQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGELS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGEQL2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGEQLF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGEQPF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGEQR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGEQRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGERFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGERQ2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGERQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGESV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGESVD()

=====
each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGESVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGETF2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGETRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGETRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGETRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGGQRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZGGRQF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZHEEVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZHEGS2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZHEGST()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZHEGVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZHENGST()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZHENTRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZHETD2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZHETRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZHETTRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding

PZLABRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLACGV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLACON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLACONSB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLACP2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLACP3()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLACPY()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLAEVSWP()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLANGE()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLAPIV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLAPV2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLAQGE()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLAQSY()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLARFB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLARFG()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLARFT()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLARZB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLARZT()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLASCL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLASE2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLASET()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLASMSUB()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLASSQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLASWP()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLATRA()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLATRD()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLATRZ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLAUU2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLAUUM()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZLAWIL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZMAX1()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPBSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPBTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPOCON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPOEQU()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPORFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPOSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPOSVX()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPOTF2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPOTRF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPOTRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPOTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPTSV()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZPTTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZSTEIN()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZTRCON()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZTREVC()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZTRRFS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZTRTI2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZTRTRI()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZTRTRS()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZTZRZF()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNG2L()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNG2R()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNGL2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNGLQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNGQL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNGQR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNGR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNGRQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNM2L()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNM2R()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNMBR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNMHR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNML2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNMLQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNMQL()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNMQR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNMR2()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNMR3()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNMRQ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNMRZ()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

PZUNMTR()

each global data object is described by an associated descriptio
the mapping between an object element and its corresponding process

objects

PCDTSV()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PCDTTRS()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PCPTSV()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PCPTTRS()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PDDTSV()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PDDTTRS()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PDPTSV()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PDPTTRS()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PSDTSV()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PSDTTRS()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PSPTSV()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PSPTTRS()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PZDTSV()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PZDTTRS()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PZPTSV()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

PZPTTRS()

as described below.
however, for tridiagonal matrices, since the objects bein
have adopted the convention that both the p-by-1 descriptor and

obtain

PCSTEIN()

note : if the eigenvectors obtained are not orthogonal, increas

PDSTEIN()

note : if the eigenvectors obtained are not orthogonal, increas

PSSTEIN()

note : if the eigenvectors obtained are not orthogonal, increas

PZSTEIN()

note : if the eigenvectors obtained are not orthogonal, increas

obtained

PCGECON()

an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), an
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PCGESVD()

where nq0 and mp0 refer, respectively, to the values obtained
the workspace is given by a workspace required on

PCGETRI()

local memory to an array of dimension (lld_a,locc(ja+n-1)).
on entry, the local pieces of the l and u obtained by th
exit, if info = 0, sub( a ) contains the inverse of the

PCHEEVX()

where norm(t) is the 1-norm of the tridiagonal matrix
obtained by reducing a to tridiagonal form
eigenvalues will be computed most accurately when abstol is

PCHEGVX()

where norm(t) is the 1-norm of the tridiagonal matrix
obtained by reducing a to tridiagonal form
eigenvalues will be computed most accurately when abstol is

PCLANHE()

of the matrix.  a sum of row (column) i of the complete matrix
can be obtained by adding along row i and column i of the th
the point of reflection.  the pictures below demonstrate this.

PCLANSY()

of the matrix.  a sum of row (column) i of the complete matrix
can be obtained by adding along row i and column i of the th
the point of reflection.  the pictures below demonstrate this.

PCLATRZ()

the  factorization is obtained by householder's method.  the kt
introduce zeros into the (m - k + 1)th row of sub( a ), is given in

PCPOCON()

an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), an
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PCSTEIN()

note : if the eigenvectors obtained are not orthogonal, increas

PCTRCON()

the norm of a(ia:ia+n-1,ja:ja+n-1) is computed and an estimate is
obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), then the reciproca
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PCTREVC()

products q*x and/or q*y, where q is an input unitary
matrix. if t was obtained from the schur factorization of a
right or left eigenvectors of a.

PCTZRZF()

the  factorization is obtained by householder's method.  the kt
introduce zeros into the (m - k + 1)th row of sub( a ), is given in

PDGECON()

an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), an
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PDGESVD()

where nq0 and mp0 refer, respectively, to the values obtained
the workspace is given by a workspace required on

PDGETRI()

local memory to an array of dimension (lld_a,locc(ja+n-1)).
on entry, the local pieces of the l and u obtained by th
exit, if info = 0, sub( a ) contains the inverse of the

PDLANSY()

of the matrix.  a sum of row (column) i of the complete matrix
can be obtained by adding along row i and column i of the th
the point of reflection.  the pictures below demonstrate this.

PDLATRZ()

the  factorization is obtained by householder's method.  the kt
the (m - k + 1)th row of sub( a ), is given in the form

PDPOCON()

an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), an
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PDSTEIN()

note : if the eigenvectors obtained are not orthogonal, increas

PDSYEVX()

where norm(t) is the 1-norm of the tridiagonal matrix
obtained by reducing a to tridiagonal form
eigenvalues will be computed most accurately when abstol is

PDSYGVX()

where norm(t) is the 1-norm of the tridiagonal matrix
obtained by reducing a to tridiagonal form
eigenvalues will be computed most accurately when abstol is

PDTRCON()

the norm of a(ia:ia+n-1,ja:ja+n-1) is computed and an estimate is
obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), then the reciproca
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PDTZRZF()

the  factorization is obtained by householder's method.  the kt
the (m - k + 1)th row of sub( a ), is given in the form

PSGECON()

an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), an
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PSGESVD()

where nq0 and mp0 refer, respectively, to the values obtained
the workspace is given by a workspace required on

PSGETRI()

local memory to an array of dimension (lld_a,locc(ja+n-1)).
on entry, the local pieces of the l and u obtained by th
exit, if info = 0, sub( a ) contains the inverse of the

PSLANSY()

of the matrix.  a sum of row (column) i of the complete matrix
can be obtained by adding along row i and column i of the th
the point of reflection.  the pictures below demonstrate this.

PSLATRZ()

the  factorization is obtained by householder's method.  the kt
the (m - k + 1)th row of sub( a ), is given in the form

PSPOCON()

an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), an
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PSSTEIN()

note : if the eigenvectors obtained are not orthogonal, increas

PSSYEVX()

where norm(t) is the 1-norm of the tridiagonal matrix
obtained by reducing a to tridiagonal form
eigenvalues will be computed most accurately when abstol is

PSSYGVX()

where norm(t) is the 1-norm of the tridiagonal matrix
obtained by reducing a to tridiagonal form
eigenvalues will be computed most accurately when abstol is

PSTRCON()

the norm of a(ia:ia+n-1,ja:ja+n-1) is computed and an estimate is
obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), then the reciproca
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PSTZRZF()

the  factorization is obtained by householder's method.  the kt
the (m - k + 1)th row of sub( a ), is given in the form

PZGECON()

an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), an
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PZGESVD()

where nq0 and mp0 refer, respectively, to the values obtained
the workspace is given by a workspace required on

PZGETRI()

local memory to an array of dimension (lld_a,locc(ja+n-1)).
on entry, the local pieces of the l and u obtained by th
exit, if info = 0, sub( a ) contains the inverse of the

PZHEEVX()

where norm(t) is the 1-norm of the tridiagonal matrix
obtained by reducing a to tridiagonal form
eigenvalues will be computed most accurately when abstol is

PZHEGVX()

where norm(t) is the 1-norm of the tridiagonal matrix
obtained by reducing a to tridiagonal form
eigenvalues will be computed most accurately when abstol is

PZLANHE()

of the matrix.  a sum of row (column) i of the complete matrix
can be obtained by adding along row i and column i of the th
the point of reflection.  the pictures below demonstrate this.

PZLANSY()

of the matrix.  a sum of row (column) i of the complete matrix
can be obtained by adding along row i and column i of the th
the point of reflection.  the pictures below demonstrate this.

PZLATRZ()

the  factorization is obtained by householder's method.  the kt
introduce zeros into the (m - k + 1)th row of sub( a ), is given in

PZPOCON()

an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), an
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PZSTEIN()

note : if the eigenvectors obtained are not orthogonal, increas

PZTRCON()

the norm of a(ia:ia+n-1,ja:ja+n-1) is computed and an estimate is
obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), then the reciproca
rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1)      ) *

PZTREVC()

products q*x and/or q*y, where q is an input unitary
matrix. if t was obtained from the schur factorization of a
right or left eigenvectors of a.

PZTZRZF()

the  factorization is obtained by householder's method.  the kt
introduce zeros into the (m - k + 1)th row of sub( a ), is given in

obvious

PCDTSV()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PCDTTRS()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PCPTSV()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PCPTTRS()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PDDTSV()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PDDTTRS()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PDPTSV()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PDPTTRS()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PSDTSV()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PSDTTRS()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PSPTSV()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PSPTTRS()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PZDTSV()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PZDTTRS()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PZPTSV()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

PZPTTRS()

partitioning, domain decomposition-type, etc.
for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&

occupies

PCTREVC()

used to store the eigenvectors.  if howmny = 'a' or 'b', m
is set to n.  each selected eigenvector occupies on

PZTREVC()

used to store the eigenvectors.  if howmny = 'a' or 'b', m
is set to n.  each selected eigenvector occupies on

occur

CDBTF2()

has been completed, but the factor u is exactly
singular, and division by zero will occur if it is use

CDTTRF()

has been completed, but the factor u is exactly
singular, and division by zero will occur if it is use

CLAHQR2()

set machine-dependent constants for the stopping criterion.
if norm(h) <= sqrt(ovfl), overflow should not occur

DDBTF2()

has been completed, but the factor u is exactly
singular, and division by zero will occur if it is use

DDTTRF()

has been completed, but the factor u is exactly
singular, and division by zero will occur if it is use

PCGETF2()

the factorization has been completed, but the factor u
is exactly singular, and division by zero will occur i

PCGETRF()

the factorization has been completed, but the factor u
is exactly singular, and division by zero will occur i

PCLACONSB()

and has each node store whatever values of the 7 it has that
the node owning h(m,m) does not.  this will occur on a borde
square blocks.  there are 5 buffers that each node stores these

PCLAHQR()

set machine-dependent constants for the stopping criterion.
if norm(h) <= sqrt(ovfl), overflow should not occur

PDGETF2()

the factorization has been completed, but the factor u
is exactly singular, and division by zero will occur i

PDGETRF()

the factorization has been completed, but the factor u
is exactly singular, and division by zero will occur i

PDLACONSB()

and has each node store whatever values of the 7 it has that
the node owning h(m,m) does not.  this will occur on a borde
square blocks.  there are 5 buffers that each node stores these

PDLAED2()

sorted set.  then it tries to deflate the size of the problem.
there are two ways in which deflation can occur:  when two or mor
z vector.  for each such occurrence the order of the related secular

PDLAHQR()

set machine-dependent constants for the stopping criterion.
if norm(h) <= sqrt(ovfl), overflow should not occur

PSGETF2()

the factorization has been completed, but the factor u
is exactly singular, and division by zero will occur i

PSGETRF()

the factorization has been completed, but the factor u
is exactly singular, and division by zero will occur i

PSLACONSB()

and has each node store whatever values of the 7 it has that
the node owning h(m,m) does not.  this will occur on a borde
square blocks.  there are 5 buffers that each node stores these

PSLAED2()

sorted set.  then it tries to deflate the size of the problem.
there are two ways in which deflation can occur:  when two or mor
z vector.  for each such occurrence the order of the related secular

PSLAHQR()

set machine-dependent constants for the stopping criterion.
if norm(h) <= sqrt(ovfl), overflow should not occur

PZGETF2()

the factorization has been completed, but the factor u
is exactly singular, and division by zero will occur i

PZGETRF()

the factorization has been completed, but the factor u
is exactly singular, and division by zero will occur i

PZLACONSB()

and has each node store whatever values of the 7 it has that
the node owning h(m,m) does not.  this will occur on a borde
square blocks.  there are 5 buffers that each node stores these

PZLAHQR()

set machine-dependent constants for the stopping criterion.
if norm(h) <= sqrt(ovfl), overflow should not occur

SDBTF2()

has been completed, but the factor u is exactly
singular, and division by zero will occur if it is use

SDTTRF()

has been completed, but the factor u is exactly
singular, and division by zero will occur if it is use

ZDBTF2()

has been completed, but the factor u is exactly
singular, and division by zero will occur if it is use

ZDTTRF()

has been completed, but the factor u is exactly
singular, and division by zero will occur if it is use

ZLAHQR2()

set machine-dependent constants for the stopping criterion.
if norm(h) <= sqrt(ovfl), overflow should not occur

occurence

PDLAED1()

when there are multiple eigenvalues or if there is a zero in
the z vector.  for each such occurence the dimension of th
performed by the routine pdlaed2.

PSLAED1()

when there are multiple eigenvalues or if there is a zero in
the z vector.  for each such occurence the dimension of th
performed by the routine pslaed2.

occurrence

PDLAED2()

eigenvalues are close together or if there is a tiny entry in the
z vector.  for each such occurrence the order of the related secula

PSLAED2()

eigenvalues are close together or if there is a tiny entry in the
z vector.  for each such occurrence the order of the related secula

occurs

PCGBTRF()

loop over levels ... only occurs if npcol > 
the two integers npact (nu. of active processors) and npstr

PDGBTRF()

loop over levels ... only occurs if npcol > 
the two integers npact (nu. of active processors) and npstr

PDLAMCH()

t     = number of (base) digits in the mantissa
rnd   = 1.0 when rounding occurs in addition, 0.0 otherwis
rmin  = underflow threshold - base**(emin-1)

PSGBTRF()

loop over levels ... only occurs if npcol > 
the two integers npact (nu. of active processors) and npstr

PSLAMCH()

t     = number of (base) digits in the mantissa
rnd   = 1.0 when rounding occurs in addition, 0.0 otherwis
rmin  = underflow threshold - base**(emin-1)

PZGBTRF()

loop over levels ... only occurs if npcol > 
the two integers npact (nu. of active processors) and npstr

odd

DLASORTE()

info    (local input) integer
this is set if the input matrix had an odd number of rea
matrix s was not originally in schur form.

PCDBTRF()

size of main (or odd) partition in each processo

PCDBTRSV()

size of main (or odd) partition in each processo

PCDTTRF()

size of main (or odd) partition in each processo

PCDTTRSV()

size of main (or odd) partition in each processo

PCGBTRF()

size of main (or odd) partition in each processo

PCPBTRF()

size of main (or odd) partition in each processo

PCPBTRSV()

size of main (or odd) partition in each processo

PCPTTRF()

size of main (or odd) partition in each processo

PCPTTRSV()

size of main (or odd) partition in each processo

PDDBTRF()

size of main (or odd) partition in each processo

PDDBTRSV()

size of main (or odd) partition in each processo

PDDTTRF()

size of main (or odd) partition in each processo

PDDTTRSV()

size of main (or odd) partition in each processo

PDGBTRF()

size of main (or odd) partition in each processo

PDPBTRF()

size of main (or odd) partition in each processo

PDPBTRSV()

size of main (or odd) partition in each processo

PDPTTRF()

size of main (or odd) partition in each processo

PDPTTRSV()

size of main (or odd) partition in each processo

PSDBTRF()

size of main (or odd) partition in each processo

PSDBTRSV()

size of main (or odd) partition in each processo

PSDTTRF()

size of main (or odd) partition in each processo

PSDTTRSV()

size of main (or odd) partition in each processo

PSGBTRF()

size of main (or odd) partition in each processo

PSPBTRF()

size of main (or odd) partition in each processo

PSPBTRSV()

size of main (or odd) partition in each processo

PSPTTRF()

size of main (or odd) partition in each processo

PSPTTRSV()

size of main (or odd) partition in each processo

PZDBTRF()

size of main (or odd) partition in each processo

PZDBTRSV()

size of main (or odd) partition in each processo

PZDTTRF()

size of main (or odd) partition in each processo

PZDTTRSV()

size of main (or odd) partition in each processo

PZGBTRF()

size of main (or odd) partition in each processo

PZPBTRF()

size of main (or odd) partition in each processo

PZPBTRSV()

size of main (or odd) partition in each processo

PZPTTRF()

size of main (or odd) partition in each processo

PZPTTRSV()

size of main (or odd) partition in each processo

SLASORTE()

info    (local input) integer
this is set if the input matrix had an odd number of rea
matrix s was not originally in schur form.

odd_size

PCDBTRF()

discard temporary matrix stored beginning in
af( (odd_size+2*bwl, bwu)*bwl, bwu+1 ) and use fo

PCPBTRF()

discard temporary matrix stored beginning in
af( (odd_size+2*bw)*bw+1 ) and use fo

PDDBTRF()

discard temporary matrix stored beginning in
af( (odd_size+2*bwl, bwu)*bwl, bwu+1 ) and use fo

PDPBTRF()

discard temporary matrix stored beginning in
af( (odd_size+2*bw)*bw+1 ) and use fo

PSDBTRF()

discard temporary matrix stored beginning in
af( (odd_size+2*bwl, bwu)*bwl, bwu+1 ) and use fo

PSPBTRF()

discard temporary matrix stored beginning in
af( (odd_size+2*bw)*bw+1 ) and use fo

PZDBTRF()

discard temporary matrix stored beginning in
af( (odd_size+2*bwl, bwu)*bwl, bwu+1 ) and use fo

PZPBTRF()

discard temporary matrix stored beginning in
af( (odd_size+2*bw)*bw+1 ) and use fo

ODPTR

PCGBTRF()

ODPTR = pointer to offdiagonal blocks in 

PDGBTRF()

ODPTR = pointer to offdiagonal blocks in 

PSGBTRF()

ODPTR = pointer to offdiagonal blocks in 

PZGBTRF()

ODPTR = pointer to offdiagonal blocks in 

oendpoint

PDLAECV()

the endpoints of the intervals. intvl(2*j-1) is the left
oendpoint f the j-th interval, and intvl(2*j) is the righ
in general, be reordered on output.

PSLAECV()

the endpoints of the intervals. intvl(2*j-1) is the left
oendpoint f the j-th interval, and intvl(2*j) is the righ
in general, be reordered on output.

off

CLAHQR2()

perform qr iterations on rows and columns ilo to i until a
submatrix of order 1 or 2 splits off at the bottom because 

CPTTRSV()

e       (input) complex array, dimension (n-1)
the (n-1) off-diagonal elements of the unit bidiagona
(see uplo).

DPTTRSV()

e       (input) complex array, dimension (n-1)
the (n-1) off-diagonal elements of the unit bidiagona
(see uplo).

PCDBTRF()

calculate new ja one while dropping off unused processors

PCDBTRSV()

calculate new ja one while dropping off unused processors

PCDTTRF()

calculate new ja one while dropping off unused processors

PCDTTRSV()

calculate new ja one while dropping off unused processors

PCGBTRF()

calculate new ja one while dropping off unused processors

PCGEBD2()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(i,i+1) for i = 1,2,...,n-1;

PCGEBRD()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(i,i+1) for i = 1,2,...,n-1;

PCHENTRD()

e       (local output) real array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PCHETD2()

e       (local output) real array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PCHETRD()

e       (local output) real array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PCHETTRD()

e       (local output) real array, dim locq(ja+n-1)
if uplo = 'u', locq(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PCLABRD()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(ia+i-1,ja+i) for i = 1,2,...,n-1;

PCLAHQR()

perform qr iterations on rows and columns ilo to i until a
submatrix of order 1 or 2 splits off at the bottom because 

PCLATRD()

e       (local output) real array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PCPBTRF()

calculate new ja one while dropping off unused processors

PCPBTRSV()

calculate new ja one while dropping off unused processors

PCPTTRF()

calculate new ja one while dropping off unused processors

PCPTTRSV()

calculate new ja one while dropping off unused processors

PCSTEIN()

e       (global input) real array, dimension (n-1)
the (n-1) off-diagonal elements of the tridiagonal matrix t
m       (global input) integer

PDDBTRF()

calculate new ja one while dropping off unused processors

PDDBTRSV()

calculate new ja one while dropping off unused processors

PDDTTRF()

calculate new ja one while dropping off unused processors

PDDTTRSV()

calculate new ja one while dropping off unused processors

PDGBTRF()

calculate new ja one while dropping off unused processors

PDGEBD2()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(i,i+1) for i = 1,2,...,n-1;

PDGEBRD()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(i,i+1) for i = 1,2,...,n-1;

PDLABRD()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(ia+i-1,ja+i) for i = 1,2,...,n-1;

PDLAEBZ()

d       (input) double precision array, dimension (2*n - 1)
contains the diagonals and the squares of the off-diagona
assumed to be interleaved in memory for better cache

PDLAED2()

rho    (global input/output) double precision
on entry, the off-diagonal element associated with the rank-
being recombined.

PDLAED3()

rho    (global input/output) double precision
on entry, the off-diagonal element associated with the rank-
being recombined.

PDLAHQR()

perform qr iterations on rows and columns ilo to i until a
submatrix of order 1 or 2 splits off at the bottom because 

PDLAPDCT()

d       (input) double precision array, dimension (2*n - 1)
contains the diagonals and the squares of the off-diagona
assumed to be interleaved in memory for better cache

PDLATRD()

e       (local output) double precision array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PDPBTRF()

calculate new ja one while dropping off unused processors

PDPBTRSV()

calculate new ja one while dropping off unused processors

PDPTTRF()

calculate new ja one while dropping off unused processors

PDPTTRSV()

calculate new ja one while dropping off unused processors

PDSTEBZ()

= 'b': ("by block") the eigenvalues will be grouped by
split-off block (see iblock, isplit) an
the block.

PDSTEIN()

e       (global input) double precision array, dimension (n-1)
the (n-1) off-diagonal elements of the tridiagonal matrix t
m       (global input) integer

PDSYNTRD()

e       (local output) double precision array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PDSYTD2()

e       (local output) double precision array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PDSYTRD()

e       (local output) double precision array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PDSYTTRD()

e       (local output) double precision array, dim locq(ja+n-1)
if uplo = 'u', locq(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PSDBTRF()

calculate new ja one while dropping off unused processors

PSDBTRSV()

calculate new ja one while dropping off unused processors

PSDTTRF()

calculate new ja one while dropping off unused processors

PSDTTRSV()

calculate new ja one while dropping off unused processors

PSGBTRF()

calculate new ja one while dropping off unused processors

PSGEBD2()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(i,i+1) for i = 1,2,...,n-1;

PSGEBRD()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(i,i+1) for i = 1,2,...,n-1;

PSLABRD()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(ia+i-1,ja+i) for i = 1,2,...,n-1;

PSLAEBZ()

d       (input) real array, dimension (2*n - 1)
contains the diagonals and the squares of the off-diagona
assumed to be interleaved in memory for better cache

PSLAED2()

rho    (global input/output) real
on entry, the off-diagonal element associated with the rank-
being recombined.

PSLAED3()

rho    (global input/output) real
on entry, the off-diagonal element associated with the rank-
being recombined.

PSLAHQR()

perform qr iterations on rows and columns ilo to i until a
submatrix of order 1 or 2 splits off at the bottom because 

PSLAPDCT()

d       (input) real array, dimension (2*n - 1)
contains the diagonals and the squares of the off-diagona
assumed to be interleaved in memory for better cache

PSLATRD()

e       (local output) real array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PSPBTRF()

calculate new ja one while dropping off unused processors

PSPBTRSV()

calculate new ja one while dropping off unused processors

PSPTTRF()

calculate new ja one while dropping off unused processors

PSPTTRSV()

calculate new ja one while dropping off unused processors

PSSTEBZ()

= 'b': ("by block") the eigenvalues will be grouped by
split-off block (see iblock, isplit) an
the block.

PSSTEIN()

e       (global input) real array, dimension (n-1)
the (n-1) off-diagonal elements of the tridiagonal matrix t
m       (global input) integer

PSSYNTRD()

e       (local output) real array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PSSYTD2()

e       (local output) real array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PSSYTRD()

e       (local output) real array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PSSYTTRD()

e       (local output) real array, dim locq(ja+n-1)
if uplo = 'u', locq(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PZDBTRF()

calculate new ja one while dropping off unused processors

PZDBTRSV()

calculate new ja one while dropping off unused processors

PZDTTRF()

calculate new ja one while dropping off unused processors

PZDTTRSV()

calculate new ja one while dropping off unused processors

PZGBTRF()

calculate new ja one while dropping off unused processors

PZGEBD2()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(i,i+1) for i = 1,2,...,n-1;

PZGEBRD()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(i,i+1) for i = 1,2,...,n-1;

PZHENTRD()

e       (local output) double precision array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PZHETD2()

e       (local output) double precision array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PZHETRD()

e       (local output) double precision array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PZHETTRD()

e       (local output) double precision array, dim locq(ja+n-1)
if uplo = 'u', locq(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PZLABRD()

locr(ia+min(m,n)-1) if m >= n; locc(ja+min(m,n)-2) otherwise.
the distributed off-diagonal elements of the bidiagona
if m >= n, e(i) = a(ia+i-1,ja+i) for i = 1,2,...,n-1;

PZLAHQR()

perform qr iterations on rows and columns ilo to i until a
submatrix of order 1 or 2 splits off at the bottom because 

PZLATRD()

e       (local output) double precision array, dimension locc(ja+n-1)
if uplo = 'u', locc(ja+n-2) otherwise. the off-diagona
uplo = 'u', e(i) = a(i+1,i) if uplo = 'l'. e is tied to the

PZPBTRF()

calculate new ja one while dropping off unused processors

PZPBTRSV()

calculate new ja one while dropping off unused processors

PZPTTRF()

calculate new ja one while dropping off unused processors

PZPTTRSV()

calculate new ja one while dropping off unused processors

PZSTEIN()

e       (global input) double precision array, dimension (n-1)
the (n-1) off-diagonal elements of the tridiagonal matrix t
m       (global input) integer

SPTTRSV()

e       (input) complex array, dimension (n-1)
the (n-1) off-diagonal elements of the unit bidiagona
(see uplo).

ZLAHQR2()

perform qr iterations on rows and columns ilo to i until a
submatrix of order 1 or 2 splits off at the bottom because 

ZPTTRSV()

e       (input) complex array, dimension (n-1)
the (n-1) off-diagonal elements of the unit bidiagona
(see uplo).

off_diagonal

PCDBTRF()

af( (odd_size+2*bwl, bwu)*bwl, bwu+1 ) and use for
off_diagonal block of reduced system
receive previously transmitted matrix section, which forms

PCDTTRF()

modify lower off_diagonal block with diagonal bloc

PCPBTRF()

af( (odd_size+2*bw)*bw+1 ) and use for
off_diagonal block of reduced system
receive previously transmitted matrix section, which forms

PCPTTRF()

modify upper off_diagonal block with diagonal bloc

PDDBTRF()

af( (odd_size+2*bwl, bwu)*bwl, bwu+1 ) and use for
off_diagonal block of reduced system
receive previously transmitted matrix section, which forms

PDDTTRF()

modify lower off_diagonal block with diagonal bloc

PDPBTRF()

af( (odd_size+2*bw)*bw+1 ) and use for
off_diagonal block of reduced system
receive previously transmitted matrix section, which forms

PDPTTRF()

modify upper off_diagonal block with diagonal bloc

PSDBTRF()

af( (odd_size+2*bwl, bwu)*bwl, bwu+1 ) and use for
off_diagonal block of reduced system
receive previously transmitted matrix section, which forms

PSDTTRF()

modify lower off_diagonal block with diagonal bloc

PSPBTRF()

af( (odd_size+2*bw)*bw+1 ) and use for
off_diagonal block of reduced system
receive previously transmitted matrix section, which forms

PSPTTRF()

modify upper off_diagonal block with diagonal bloc

PZDBTRF()

af( (odd_size+2*bwl, bwu)*bwl, bwu+1 ) and use for
off_diagonal block of reduced system
receive previously transmitted matrix section, which forms

PZDTTRF()

modify lower off_diagonal block with diagonal bloc

PZPBTRF()

af( (odd_size+2*bw)*bw+1 ) and use for
off_diagonal block of reduced system
receive previously transmitted matrix section, which forms

PZPTTRF()

modify upper off_diagonal block with diagonal bloc

offdiag

PCDTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PCPTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PDDTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PDPTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PSDTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PSPTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PZDTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PZPTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

offdiagonal

PCDBTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PCDBTRSV()

use offdiagonal block to calculate modification to diag bloc

PCDTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PCDTTRSV()

use offdiagonal block to calculate modification to diag bloc

PCGBTRF()

define the initial dimensions of the diagonal blocks
the offdiagonal blocks (for mycol > 0) are of size bm by b

PCLASE2()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals.  pclase2 requires that only dimension of the matri

PCLASET()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals
notes

PCPBTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PCPBTRSV()

use offdiagonal block to calculate modification to diag bloc

PCPTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PCPTTRSV()

use offdiagonal block to calculate modification to diag bloc

PDDBTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PDDBTRSV()

use offdiagonal block to calculate modification to diag bloc

PDDTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PDDTTRSV()

use offdiagonal block to calculate modification to diag bloc

PDGBTRF()

define the initial dimensions of the diagonal blocks
the offdiagonal blocks (for mycol > 0) are of size bm by b

PDLASE2()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals.  pdlase2 requires that only dimension of the matri

PDLASET()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals
notes

PDPBTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PDPBTRSV()

use offdiagonal block to calculate modification to diag bloc

PDPTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PDPTTRSV()

use offdiagonal block to calculate modification to diag bloc

PSDBTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PSDBTRSV()

use offdiagonal block to calculate modification to diag bloc

PSDTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PSDTTRSV()

use offdiagonal block to calculate modification to diag bloc

PSGBTRF()

define the initial dimensions of the diagonal blocks
the offdiagonal blocks (for mycol > 0) are of size bm by b

PSLASE2()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals.  pslase2 requires that only dimension of the matri

PSLASET()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals
notes

PSPBTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PSPBTRSV()

use offdiagonal block to calculate modification to diag bloc

PSPTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PSPTTRSV()

use offdiagonal block to calculate modification to diag bloc

PZDBTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PZDBTRSV()

use offdiagonal block to calculate modification to diag bloc

PZDTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PZDTTRSV()

use offdiagonal block to calculate modification to diag bloc

PZGBTRF()

define the initial dimensions of the diagonal blocks
the offdiagonal blocks (for mycol > 0) are of size bm by b

PZLASE2()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals.  pzlase2 requires that only dimension of the matri

PZLASET()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals
notes

PZPBTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PZPBTRSV()

use offdiagonal block to calculate modification to diag bloc

PZPTTRF()

****************************************************************
receive offdiagonal block from processor to right
from a different processor than otherwise.

PZPTTRSV()

use offdiagonal block to calculate modification to diag bloc

offdiagonals

PCLASE2()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals.  pclase2 requires that only dimension of the matri

PCLASET()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals
notes

PDLASE2()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals.  pdlase2 requires that only dimension of the matri

PDLASET()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals
notes

PSLASE2()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals.  pslase2 requires that only dimension of the matri

PSLASET()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals
notes

PZLASE2()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals.  pzlase2 requires that only dimension of the matri

PZLASET()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals
notes

Offset

PCDBTRF()

Offset in columns to beginning of main partition in each pro

PCDBTRSV()

Offset in columns to beginning of main partition in each pro

PCDTTRF()

Offset in columns to beginning of main partition in each pro

PCDTTRSV()

Offset in columns to beginning of main partition in each pro

PCGBTRF()

Offset in columns to beginning of main partition in each pro

PCLAHRD()

k       (global input) integer
the Offset for the reduction. elements below the k-t

PCPBTRF()

Offset in columns to beginning of main partition in each pro

PCPBTRSV()

Offset in columns to beginning of main partition in each pro

PCPTTRF()

Offset in columns to beginning of main partition in each pro

PCPTTRSV()

Offset in columns to beginning of main partition in each pro

PDDBTRF()

Offset in columns to beginning of main partition in each pro

PDDBTRSV()

Offset in columns to beginning of main partition in each pro

PDDTTRF()

Offset in columns to beginning of main partition in each pro

PDDTTRSV()

Offset in columns to beginning of main partition in each pro

PDGBTRF()

Offset in columns to beginning of main partition in each pro

PDLAHRD()

k       (global input) integer
the Offset for the reduction. elements below the k-t

PDPBTRF()

Offset in columns to beginning of main partition in each pro

PDPBTRSV()

Offset in columns to beginning of main partition in each pro

PDPTTRF()

Offset in columns to beginning of main partition in each pro

PDPTTRSV()

Offset in columns to beginning of main partition in each pro

PSDBTRF()

Offset in columns to beginning of main partition in each pro

PSDBTRSV()

Offset in columns to beginning of main partition in each pro

PSDTTRF()

Offset in columns to beginning of main partition in each pro

PSDTTRSV()

Offset in columns to beginning of main partition in each pro

PSGBTRF()

Offset in columns to beginning of main partition in each pro

PSLAHRD()

k       (global input) integer
the Offset for the reduction. elements below the k-t

PSPBTRF()

Offset in columns to beginning of main partition in each pro

PSPBTRSV()

Offset in columns to beginning of main partition in each pro

PSPTTRF()

Offset in columns to beginning of main partition in each pro

PSPTTRSV()

Offset in columns to beginning of main partition in each pro

PZDBTRF()

Offset in columns to beginning of main partition in each pro

PZDBTRSV()

Offset in columns to beginning of main partition in each pro

PZDTTRF()

Offset in columns to beginning of main partition in each pro

PZDTTRSV()

Offset in columns to beginning of main partition in each pro

PZGBTRF()

Offset in columns to beginning of main partition in each pro

PZLAHRD()

k       (global input) integer
the Offset for the reduction. elements below the k-t

PZPBTRF()

Offset in columns to beginning of main partition in each pro

PZPBTRSV()

Offset in columns to beginning of main partition in each pro

PZPTTRF()

Offset in columns to beginning of main partition in each pro

PZPTTRSV()

Offset in columns to beginning of main partition in each pro

old

PCDBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PCDBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PCDTSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PCDTTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PCGBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PCGBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PCHENTRD()

support for uplo='u' is limited to calling the old, slow, pchetr

PCPBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PCPBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PCPTSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PCPTTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PDDBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PDDBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PDDTSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PDDTTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PDGBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PDGBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PDPBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PDPBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PDPTSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PDPTTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PDSYNTRD()

support for uplo='u' is limited to calling the old, slow, pdsytr

PSDBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PSDBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PSDTSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PSDTTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PSGBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PSGBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PSPBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PSPBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PSPTSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PSPTTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PSSYNTRD()

support for uplo='u' is limited to calling the old, slow, pssytr

PZDBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PZDBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PZDTSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PZDTTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PZGBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PZGBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PZHENTRD()

support for uplo='u' is limited to calling the old, slow, pzhetr

PZPBSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PZPBTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PZPTSV()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

PZPTTRS()

restriction on nb, the size of each block on each processor,
must hold
the bulk of parallel computation is done on the matrix of size

OLDGP

CSTEQR2()

gp = ( ( OLDGP+p )-( d( l )-p ) ) 
make sure that we are making progress

ZSTEQR2()

gp = ( ( OLDGP+p )-( d( l )-p ) ) 
make sure that we are making progress

OLDRP

CSTEQR2()

gp = ( ( oldgp+p )-( d( l )-p ) ) /
$              ( two*( c*OLDRP-b )+safmin 

ZSTEQR2()

gp = ( ( oldgp+p )-( d( l )-p ) ) /
$              ( two*( c*OLDRP-b )+safmin 

once

CLAREF()

block   (global input) logical
if .true., then apply several reflectors at once and rea
if .false., apply the single reflector given by v2, v3,

DLAREF()

block   (global input) logical
if .true., then apply several reflectors at once and rea
if .false., apply the single reflector given by v2, v3,

PCLAHQR()

communication sometimes k1(ki)=hbl-2 & k2(ki)=hbl-1 so both
border messages can be handled at once
rules:

PZLAHQR()

communication sometimes k1(ki)=hbl-2 & k2(ki)=hbl-1 so both
border messages can be handled at once
rules:

SLAREF()

block   (global input) logical
if .true., then apply several reflectors at once and rea
if .false., apply the single reflector given by v2, v3,

ZLAREF()

block   (global input) logical
if .true., then apply several reflectors at once and rea
if .false., apply the single reflector given by v2, v3,

one

CDTTRSV()

cdttrsv solves one of the systems of equation
u * x = b,  u**t * x = b,  or  u**h * x = b,

CLAHQR2()

restore the hessenberg form in the (k-1)th column, and thus
chases the bulge one step toward the bottom of the activ

CLAREF()

claref applies one or several householder reflectors of size 
rows or columns.

CPTTRSV()

cpttrsv solves one of the triangular system
u * x = b, or  u**h * x = b,

DDTTRSV()

ddttrsv solves one of the systems of equation
u * x = b,  u**t * x = b,  or  u**h * x = b,

DLAPST()

partition d( start:endd ) and stack parts, largest one firs
choose partition entry as median of 3

DLAREF()

dlaref applies one or several householder reflectors of size 
rows or columns.

DLASORTE()

dlasorte sorts eigenpairs so that real eigenpairs are together and
complex are together.  this way one can employ 2x2 shifts easil
this routine does no parallel work.

DLASRT2()

partition d( start:endd ) and stack parts, largest one firs
choose partition entry as median of 3

DPTTRSV()

dpttrsv solves one of the triangular system
where l is the cholesky factor of a hermitian positive

DSTEIN2()

skip all the work if the block size is one

PCDBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PCDBTRF()

calculate new ja one while dropping off unused processors

PCDBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PCDBTRSV()

calculate new ja one while dropping off unused processors

PCDTSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PCDTTRF()

calculate new ja one while dropping off unused processors

PCDTTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PCDTTRSV()

calculate new ja one while dropping off unused processors

PCGBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PCGBTRF()

calculate new ja one while dropping off unused processors

PCGBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PCGGQRF()

where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix,
and r and t assume one of the forms
if n >= m,  r = ( r11 ) m  ,   or if n < m,  r = ( r11  r12 ) n,

PCGGRQF()

where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix,
and r and t assume one of the forms
if m <= n,  r = ( 0  r12 ) m,   or if m > n,  r = ( r11 ) m-n,

PCHEEVX()

tol may be decreased until all eigenvectors to be
reorthogonalized can be stored in one process
a default value of 10^-3 is used if orfac is negative.

PCHEGVX()

tol may be decreased until all eigenvectors to be
reorthogonalized can be stored in one process
a default value of 10^-3 is used if orfac is negative.

PCHETTRD()

temporary variables.  the following variables are used within
a few lines after they are set and do hold state from one loo

PCLACON()

the serial version clacon has been contributed by nick higham,
university of manchester. it was originally named sonest, date

PCLACONSB()

up and left and a buffer to send right.  each of these buffers
is actually stored in one buffer buf where buf(istr1+1) start
the values are stored, if there are any values that a node

PCLACP3()

array into a local replicated array or vise versa.  notice that
the entire submatrix that is copied gets placed on one node o
can receive, or just one row or column of nodes.

PCLAEVSWP()

the eigenvectors on input.  each eigenvector resides entirely
in one process.  each process holds a contiguous set o
process holds is:  sum for i=[0,iam-1) of nvs(i)

PCLAHQR()

everyone needs to receive the new nbulg

PCLAMR1D()

pclamr1d redistributes a one-dimensional row vector from one dat

PCLANGE()

pclange returns the value of the one norm, or the frobenius norm
distributed matrix sub( a ) = a(ia:ia+m-1, ja:ja+n-1).

PCLANHS()

only one process ro

PCLASSQ()

the routine makes only one pass through the vector sub( x )
notes

PCLASWP()

pclaswp performs a series of row or column interchanges on
the distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1).  one
sub( a ). this routine assumes that the pivoting information has

PCLAUU2()

no communication is performed by this routine, the matrix to operate
on should be strictly local to one process
notes

PCMAX1()

then, the processes which receive the answer will be (note that if
an operation involves more than one vector, the processes which re
each vector):

PCPBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PCPBTRF()

calculate new ja one while dropping off unused processors

PCPBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PCPBTRSV()

calculate new ja one while dropping off unused processors

PCPTSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PCPTTRF()

calculate new ja one while dropping off unused processors

PCPTTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PCPTTRSV()

calculate new ja one while dropping off unused processors

PCSTEIN()

individual process. if insufficient workspace is allocated, the
expected orthogonalization may not be done
note : if the eigenvectors obtained are not orthogonal, increase

PCTREVC()

used to store the eigenvectors.  if howmny = 'a' or 'b', m
is set to n.  each selected eigenvector occupies one

PCTRTI2()

block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be
contained in one and only one process memory space (local operation)
notes

PDDBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PDDBTRF()

calculate new ja one while dropping off unused processors

PDDBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PDDBTRSV()

calculate new ja one while dropping off unused processors

PDDTSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PDDTTRF()

calculate new ja one while dropping off unused processors

PDDTTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PDDTTRSV()

calculate new ja one while dropping off unused processors

PDGBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PDGBTRF()

calculate new ja one while dropping off unused processors

PDGBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PDGGQRF()

where q is an n-by-n orthogonal matrix, z is a p-by-p orthogonal
matrix, and r and t assume one of the forms
if n >= m,  r = ( r11 ) m  ,   or if n < m,  r = ( r11  r12 ) n,

PDGGRQF()

where q is an n-by-n orthogonal matrix, z is a p-by-p orthogonal
matrix, and r and t assume one of the forms
if m <= n,  r = ( 0  r12 ) m,   or if m > n,  r = ( r11 ) m-n,

PDLACON()

the serial version dlacon has been contributed by nick higham,
university of manchester. it was originally named sonest, date

PDLACONSB()

up and left and a buffer to send right.  each of these buffers
is actually stored in one buffer buf where buf(istr1+1) start
the values are stored, if there are any values that a node

PDLACP3()

array into a local replicated array or vise versa.  notice that
the entire submatrix that is copied gets placed on one node o
can receive, or just one row or column of nodes.

PDLAED1()

pdlaed1 computes the updated eigensystem of a diagonal
matrix after modification by a rank-one symmetric matrix

PDLAED2()

z vector.  for each such occurrence the order of the related secular
equation problem is reduced by one
arguments

PDLAEVSWP()

the eigenvectors on input.  each eigenvector resides entirely
in one process.  each process holds a contiguous set o
process holds is:  sum for i=[0,iam-1) of nvs(i)

PDLAHQR()

"congested."  as a remedy, when we first hit a border, a 6x6
*local* matrix is generated on one node (called smalla) an
passed back and everything stays a lot simpler.

PDLAMR1D()

pdlamr1d redistributes a one-dimensional row vector from one dat

PDLANGE()

pdlange returns the value of the one norm, or the frobenius norm
distributed matrix sub( a ) = a(ia:ia+m-1, ja:ja+n-1).

PDLANHS()

only one process ro

PDLARED1D()

work    (local workspace) double precision dimension (lwork)
used to hold the buffers sent from one process to anothe
lwork   (local input) integer size of work array

PDLARED2D()

work    (local workspace) double precision dimension (lwork)
used to hold the buffers sent from one process to anothe
lwork   (local input) integer size of work array

PDLASSQ()

the routine makes only one pass through the vector sub( x )
notes

PDLASWP()

pdlaswp performs a series of row or column interchanges on
the distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1).  one
sub( a ). this routine assumes that the pivoting information has

PDLAUU2()

no communication is performed by this routine, the matrix to operate
on should be strictly local to one process
notes

PDPBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PDPBTRF()

calculate new ja one while dropping off unused processors

PDPBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PDPBTRSV()

calculate new ja one while dropping off unused processors

PDPTSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PDPTTRF()

calculate new ja one while dropping off unused processors

PDPTTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PDPTTRSV()

calculate new ja one while dropping off unused processors

PDSTEIN()

individual process. if insufficient workspace is allocated, the
expected orthogonalization may not be done
note : if the eigenvectors obtained are not orthogonal, increase

PDSYEVX()

tol may be decreased until all eigenvectors to be
reorthogonalized can be stored in one process
a default value of 10^-3 is used if orfac is negative.

PDSYGVX()

tol may be decreased until all eigenvectors to be
reorthogonalized can be stored in one process
a default value of 10^-3 is used if orfac is negative.

PDSYTTRD()

temporary variables.  the following variables are used within
a few lines after they are set and do hold state from one loo

PDTRTI2()

block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be
contained in one and only one process memory space (local operation)
notes

PDZSUM1()

then, the processes which receive the answer will be (note that if
an operation involves more than one vector, the processes which re
each vector):

PSCSUM1()

then, the processes which receive the answer will be (note that if
an operation involves more than one vector, the processes which re
each vector):

PSDBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PSDBTRF()

calculate new ja one while dropping off unused processors

PSDBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PSDBTRSV()

calculate new ja one while dropping off unused processors

PSDTSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PSDTTRF()

calculate new ja one while dropping off unused processors

PSDTTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PSDTTRSV()

calculate new ja one while dropping off unused processors

PSGBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PSGBTRF()

calculate new ja one while dropping off unused processors

PSGBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PSGGQRF()

where q is an n-by-n orthogonal matrix, z is a p-by-p orthogonal
matrix, and r and t assume one of the forms
if n >= m,  r = ( r11 ) m  ,   or if n < m,  r = ( r11  r12 ) n,

PSGGRQF()

where q is an n-by-n orthogonal matrix, z is a p-by-p orthogonal
matrix, and r and t assume one of the forms
if m <= n,  r = ( 0  r12 ) m,   or if m > n,  r = ( r11 ) m-n,

PSLACON()

the serial version slacon has been contributed by nick higham,
university of manchester. it was originally named sonest, date

PSLACONSB()

up and left and a buffer to send right.  each of these buffers
is actually stored in one buffer buf where buf(istr1+1) start
the values are stored, if there are any values that a node

PSLACP3()

array into a local replicated array or vise versa.  notice that
the entire submatrix that is copied gets placed on one node o
can receive, or just one row or column of nodes.

PSLAED1()

pslaed1 computes the updated eigensystem of a diagonal
matrix after modification by a rank-one symmetric matrix

PSLAED2()

z vector.  for each such occurrence the order of the related secular
equation problem is reduced by one
arguments

PSLAEVSWP()

the eigenvectors on input.  each eigenvector resides entirely
in one process.  each process holds a contiguous set o
process holds is:  sum for i=[0,iam-1) of nvs(i)

PSLAHQR()

"congested."  as a remedy, when we first hit a border, a 6x6
*local* matrix is generated on one node (called smalla) an
passed back and everything stays a lot simpler.

PSLAMR1D()

pslamr1d redistributes a one-dimensional row vector from one dat

PSLANGE()

pslange returns the value of the one norm, or the frobenius norm
distributed matrix sub( a ) = a(ia:ia+m-1, ja:ja+n-1).

PSLANHS()

only one process ro

PSLARED1D()

work    (local workspace) real dimension (lwork)
used to hold the buffers sent from one process to anothe
lwork   (local input) integer size of work array

PSLARED2D()

work    (local workspace) real dimension (lwork)
used to hold the buffers sent from one process to anothe
lwork   (local input) integer size of work array

PSLASSQ()

the routine makes only one pass through the vector sub( x )
notes

PSLASWP()

pslaswp performs a series of row or column interchanges on
the distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1).  one
sub( a ). this routine assumes that the pivoting information has

PSLAUU2()

no communication is performed by this routine, the matrix to operate
on should be strictly local to one process
notes

PSPBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PSPBTRF()

calculate new ja one while dropping off unused processors

PSPBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PSPBTRSV()

calculate new ja one while dropping off unused processors

PSPTSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PSPTTRF()

calculate new ja one while dropping off unused processors

PSPTTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PSPTTRSV()

calculate new ja one while dropping off unused processors

PSSTEIN()

individual process. if insufficient workspace is allocated, the
expected orthogonalization may not be done
note : if the eigenvectors obtained are not orthogonal, increase

PSSYEVX()

tol may be decreased until all eigenvectors to be
reorthogonalized can be stored in one process
a default value of 10^-3 is used if orfac is negative.

PSSYGVX()

tol may be decreased until all eigenvectors to be
reorthogonalized can be stored in one process
a default value of 10^-3 is used if orfac is negative.

PSSYTTRD()

temporary variables.  the following variables are used within
a few lines after they are set and do hold state from one loo

PSTRTI2()

block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be
contained in one and only one process memory space (local operation)
notes

PZDBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PZDBTRF()

calculate new ja one while dropping off unused processors

PZDBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PZDBTRSV()

calculate new ja one while dropping off unused processors

PZDTSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PZDTTRF()

calculate new ja one while dropping off unused processors

PZDTTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PZDTTRSV()

calculate new ja one while dropping off unused processors

PZGBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PZGBTRF()

calculate new ja one while dropping off unused processors

PZGBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PZGGQRF()

where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix,
and r and t assume one of the forms
if n >= m,  r = ( r11 ) m  ,   or if n < m,  r = ( r11  r12 ) n,

PZGGRQF()

where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix,
and r and t assume one of the forms
if m <= n,  r = ( 0  r12 ) m,   or if m > n,  r = ( r11 ) m-n,

PZHEEVX()

tol may be decreased until all eigenvectors to be
reorthogonalized can be stored in one process
a default value of 10^-3 is used if orfac is negative.

PZHEGVX()

tol may be decreased until all eigenvectors to be
reorthogonalized can be stored in one process
a default value of 10^-3 is used if orfac is negative.

PZHETTRD()

temporary variables.  the following variables are used within
a few lines after they are set and do hold state from one loo

PZLACON()

the serial version zlacon has been contributed by nick higham,
university of manchester. it was originally named sonest, date

PZLACONSB()

up and left and a buffer to send right.  each of these buffers
is actually stored in one buffer buf where buf(istr1+1) start
the values are stored, if there are any values that a node

PZLACP3()

array into a local replicated array or vise versa.  notice that
the entire submatrix that is copied gets placed on one node o
can receive, or just one row or column of nodes.

PZLAEVSWP()

the eigenvectors on input.  each eigenvector resides entirely
in one process.  each process holds a contiguous set o
process holds is:  sum for i=[0,iam-1) of nvs(i)

PZLAHQR()

everyone needs to receive the new nbulg

PZLAMR1D()

pzlamr1d redistributes a one-dimensional row vector from one dat

PZLANGE()

pzlange returns the value of the one norm, or the frobenius norm
distributed matrix sub( a ) = a(ia:ia+m-1, ja:ja+n-1).

PZLANHS()

only one process ro

PZLASSQ()

the routine makes only one pass through the vector sub( x )
notes

PZLASWP()

pzlaswp performs a series of row or column interchanges on
the distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1).  one
sub( a ). this routine assumes that the pivoting information has

PZLAUU2()

no communication is performed by this routine, the matrix to operate
on should be strictly local to one process
notes

PZMAX1()

then, the processes which receive the answer will be (note that if
an operation involves more than one vector, the processes which re
each vector):

PZPBSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PZPBTRF()

calculate new ja one while dropping off unused processors

PZPBTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PZPBTRSV()

calculate new ja one while dropping off unused processors

PZPTSV()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PZPTTRF()

calculate new ja one while dropping off unused processors

PZPTTRS()

of the divide and conquer algorithm as a task-parallel algorithm.
this formula in words is: no processor may have more than one

PZPTTRSV()

calculate new ja one while dropping off unused processors

PZSTEIN()

individual process. if insufficient workspace is allocated, the
expected orthogonalization may not be done
note : if the eigenvectors obtained are not orthogonal, increase

PZTREVC()

used to store the eigenvectors.  if howmny = 'a' or 'b', m
is set to n.  each selected eigenvector occupies one

PZTRTI2()

block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be
contained in one and only one process memory space (local operation)
notes

SDTTRSV()

sdttrsv solves one of the systems of equation
u * x = b,  u**t * x = b,  or  u**h * x = b,

SLAPST()

partition d( start:endd ) and stack parts, largest one firs
choose partition entry as median of 3

SLAREF()

slaref applies one or several householder reflectors of size 
rows or columns.

SLASORTE()

slasorte sorts eigenpairs so that real eigenpairs are together and
complex are together.  this way one can employ 2x2 shifts easil
this routine does no parallel work.

SLASRT2()

partition d( start:endd ) and stack parts, largest one firs
choose partition entry as median of 3

SPTTRSV()

spttrsv solves one of the triangular system
where l is the cholesky factor of a hermitian positive

SSTEIN2()

skip all the work if the block size is one

ZDTTRSV()

zdttrsv solves one of the systems of equation
u * x = b,  u**t * x = b,  or  u**h * x = b,

ZLAHQR2()

restore the hessenberg form in the (k-1)th column, and thus
chases the bulge one step toward the bottom of the activ

ZLAREF()

zlaref applies one or several householder reflectors of size 
rows or columns.

ZPTTRSV()

zpttrsv solves one of the triangular system
u * x = b, or  u**h * x = b,

ones

PCHENTRD()

pchentrd is faster than pchetrd on almost all matrices,
particularly small ones (i.e. n < 500 * sqrt(p) ), provided tha

PCPOEQU()

factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri-
buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones o
of b within a factor n of the smallest possible condition number

PDLAED1()

where z = q'u, u is a vector of length n with ones in th

PDPOEQU()

factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri-
buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones o
of b within a factor n of the smallest possible condition number

PDSTEBZ()

does not converge for some or all eigenvalues, info is set
to 1 and the ones for which it did not are identified by 

PDSYNTRD()

pdsyntrd is faster than pdsytrd on almost all matrices,
particularly small ones (i.e. n < 500 * sqrt(p) ), provided tha

PSLAED1()

where z = q'u, u is a vector of length n with ones in th

PSPOEQU()

factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri-
buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones o
of b within a factor n of the smallest possible condition number

PSSTEBZ()

does not converge for some or all eigenvalues, info is set
to 1 and the ones for which it did not are identified by 

PSSYNTRD()

pssyntrd is faster than pssytrd on almost all matrices,
particularly small ones (i.e. n < 500 * sqrt(p) ), provided tha

PZHENTRD()

pzhentrd is faster than pzhetrd on almost all matrices,
particularly small ones (i.e. n < 500 * sqrt(p) ), provided tha

PZPOEQU()

factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri-
buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones o
of b within a factor n of the smallest possible condition number

only

CDTTRF()

where l is a product of unit lower bidiagonal
matrices and u is upper triangular with nonzeros in only the mai

CLAHQR2()

i1 and i2 are the indices of the first row and last column of h
to which transformations must be applied. if eigenvalues only ar

CLAMSH()

that can be sent through.
clamsh should only be called when there are multiple shifts/bulge
unreduced hessenberg matrix because of two or more consecutive

CLAREF()

on entry, the second matrix to receive column reflections.
this is changed only if wantz is set
ldz     (local input) integer

DDTTRF()

where l is a product of unit lower bidiagonal
matrices and u is upper triangular with nonzeros in only the mai

DLAMSH ()

that can be sent through.
dlamsh should only be called when there are multiple shifts/bulge
unreduced hessenberg matrix because of two or more consecutive small

DLAREF()

on entry, the second matrix to receive column reflections.
this is changed only if wantz is set
ldz     (local input) integer

PCDBSV()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PCDBTRF()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PCDBTRS()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PCDBTRSV()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PCDTSV()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PCDTTRF()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PCDTTRS()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PCDTTRSV()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PCGBSV()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PCGBTRF()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PCGBTRS()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

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()

singular values are returned in array s in decreasing order and
only the first min(m,n) columns of u and rows of vt = v**t ar

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()

in its present form, pcheev assumes a homogeneous system and makes
only spot checks of the consistency of the eigenvalues across th
heterogeneous system may return incorrect results without any error

PCHEEVD()

jobz    (input) character*1
= 'n':  compute eigenvalues only;    (not implemented yet

PCHEEVX()

the appropriate slmake.inc file to include the compiler switch
-dno_ieee.  this switch only affects the compilation of pslaiect.c
arguments

PCHEGVX()

jobz    (global input) character*1
= 'n':  compute eigenvalues only

PCHENGST()

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

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

PCHETTRD()

the process grid must be square ( i.e. nprow = npcol ) and
only lower triangular storage is supported
local variables

PCLACGV()

incx    (global input) integer
the global increment for the elements of x. only two value
incx must not be zero.

PCLACP2()

a(ia:ia+m-1,ja:ja+n-1) and sub( b ) denotes b(ib:ib+m-1,jb:jb+n-1).
pclacp2 requires that only dimension of the matrix operands i

PCLAHQR()

i1 and i2 are the indices of the first row and last column of h
to which transformations must be applied. if eigenvalues only ar

PCLAMR1D()

although all processes call pcgemr2d, only the processes that ow
first column of b receive data.  the calls to cgebs2d/cgebr2d

PCLANHE()

if the matrix is hermitian, we address only a triangular portio
can be obtained by adding along row i and column i of the the

PCLANHS()

only one process ro

PCLANSY()

if the matrix is symmetric, we address only a triangular portio
can be obtained by adding along row i and column i of the the

PCLARF()

is sub( c ) only distributed over a process row 

PCLARFC()

is sub( c ) only distributed over a process row 

PCLARFG()

incx    (global input) integer
the global increment for the elements of x. only two value
incx must not be zero.

PCLARZ()

is sub( c ) only distributed over a process row 

PCLARZB()

currently, only storev = 'r' and direct = 'b' are supported
notes

PCLARZC()

is sub( c ) only distributed over a process row 

PCLARZT()

currently, only storev = 'r' and direct = 'b' are supported
notes

PCLASE2()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals.  pclase2 requires that only dimension of the matri

PCLASSQ()

the routine makes only one pass through the vector sub( x )
notes

PCLASWP()

already been broadcast along the process row or column.
also note that this routine will only work for k1-k2 being in th
pclapiv.

PCMAX1()

when the result of a vector-oriented pblas call is a scalar, it will
be made available only within the scope which owns the vector(s
then, the processes which receive the answer will be (note that if

PCPBSV()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PCPBTRF()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PCPBTRS()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PCPBTRSV()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

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

PCPOEQU()

n-by-n hermitian positive definite distributed matrix
sub( a ) whose scaling factors are to be computed.  only th

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

PCPTSV()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PCPTTRF()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PCPTTRS()

important note: the current version of this code supports
only ib=j
descb   (global and local input) integer array of dimension dlen.

PCPTTRSV()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PCSRSCL()

incx    (global input) pointer to integer
the global increment for the elements of x. only two value

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

PCTREVC()

side    (global input) character*1
= 'r':  compute right eigenvectors only
= 'b':  compute both right and left eigenvectors.

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

PCTRTI2()

block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be
contained in one and only one process memory space (local operation)
notes

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

PDDBSV()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PDDBTRF()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PDDBTRS()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PDDBTRSV()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PDDTSV()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PDDTTRF()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PDDTTRS()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PDDTTRSV()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PDGBSV()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PDGBTRF()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PDGBTRS()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

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()

singular values are returned in array s in decreasing order and
only the first min(m,n) columns of u and rows of vt = v**t ar

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

PDLACP2()

a(ia:ia+m-1,ja:ja+n-1) and sub( b ) denotes b(ib:ib+m-1,jb:jb+n-1).
pdlacp2 requires that only dimension of the matrix operands i

PDLAED2()

q matrix into three groups:  the first group contains non-zero
elements only at and above n1, the second contain

PDLAHQR()

i1 and i2 are the indices of the first row and last column of h
to which transformations must be applied. if eigenvalues only ar

PDLAMR1D()

although all processes call pdgemr2d, only the processes that ow
first column of b receive data.  the calls to dgebs2d/dgebr2d

PDLANHS()

only one process ro

PDLANSY()

if the matrix is symmetric, we address only a triangular portio
can be obtained by adding along row i and column i of the the

PDLARF()

is sub( c ) only distributed over a process row 

PDLARFG()

incx    (global input) integer
the global increment for the elements of x. only two value
incx must not be zero.

PDLARZ()

is sub( c ) only distributed over a process row 

PDLARZB()

currently, only storev = 'r' and direct = 'b' are supported
notes

PDLARZT()

currently, only storev = 'r' and direct = 'b' are supported
notes

PDLASE2()

a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on the
offdiagonals.  pdlase2 requires that only dimension of the matri

PDLASSQ()

the routine makes only one pass through the vector sub( x )
notes

PDLASWP()

already been broadcast along the process row or column.
also note that this routine will only work for k1-k2 being in th
pdlapiv.

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

PDPBSV()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PDPBTRF()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PDPBTRS()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PDPBTRSV()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

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

PDPOEQU()

n-by-n symmetric positive definite distributed matrix
sub( a ) whose scaling factors are to be computed.  only th

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

PDPTSV()

depends on a variety of parameters, especially the bandwidth.
currently, only algorithms designed for the case n/p >> bw ar
partitioning, domain decomposition-type, etc.

PDPTTRF()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PDPTTRS()

important note: the current version of this code supports
only ib=j
descb   (global and local input) integer array of dimension dlen.

PDPTTRSV()

form a new blacs grid (the "standard form" grid) with only proc
starting at csrc=0, with ja modified to reflect dropped procs.

PDRSCL()

incx    (global input) pointer to integer
the global increment for the elements of x. only two value

PDSTEBZ()

isplit(nsplit-1)+1 through isplit(nsplit)=n.
(only the first nsplit elements will actually be used, bu
have, n words must be reserved for isplit.)

PDSTEDC()

compz   (input) character*1
= 'n':  compute eigenvalues only.    (not implemented yet
= 'v':  compute eigenvectors of original dense symmetric

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()

specifies whether or not to compute the eigenvectors:
= 'n':  compute eigenvalues only

PDSYEVD()

jobz    (input) character*1
= 'n':  compute eigenvalues only;     (not implemented yet

PDSYEVX()

the appropriate slmake.inc file to include the compiler switch
-dno_ieee.  this switch only affects the compilation of pdlaiect.c
arguments

PDSYGVX()

jobz    (global input) character*1
= 'n':  compute eigenvalues only

PDSYNGST()

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

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

PDSYTTRD()

the process grid must be square ( i.e. nprow = npcol ) and
only lower triangular storage is supported
local variables

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

PDTRTI2()

block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be
contained in one and only one process memory space (local operation)
notes

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

PDZSUM1()

when the result of a vector-oriented pblas call is a scalar, it will
be made available only within the scope which owns the vector(s
then, the processes which receive the answer will be (note that if

PJLAENV()

at present, only n1 is used, and it (n1) is used only fo