B_i

PCDBTRF()

perform the triangular system solve {l_i}{{bu'}_i} = {B_i

PCGBTRF()

transfer triangle B_i of local matrix to next processo

PCPBTRF()

apply factorization to odd-even connection block B_i
conjugate transpose the connection block in preparation.

PCPTTRF()

apply factorization to odd-even connection block B_i

PDDBTRF()

perform the triangular system solve {l_i}{{bu'}_i} = {B_i

PDGBTRF()

transfer triangle B_i of local matrix to next processo

PDPBTRF()

apply factorization to odd-even connection block B_i
transpose the connection block in preparation.

PDPTTRF()

apply factorization to odd-even connection block B_i

PSDBTRF()

perform the triangular system solve {l_i}{{bu'}_i} = {B_i

PSGBTRF()

transfer triangle B_i of local matrix to next processo

PSPBTRF()

apply factorization to odd-even connection block B_i
transpose the connection block in preparation.

PSPTTRF()

apply factorization to odd-even connection block B_i

PZDBTRF()

perform the triangular system solve {l_i}{{bu'}_i} = {B_i

PZGBTRF()

transfer triangle B_i of local matrix to next processo

PZPBTRF()

apply factorization to odd-even connection block B_i
conjugate transpose the connection block in preparation.

PZPTTRF()

apply factorization to odd-even connection block B_i

back

PCDBTRF()

move the resulting block back to its location in main storage

PCHETTRD()

this brings us back to the point at which mvr2 is called

PCLAHQR()

work is done on that.  at the end of the border, the data is
passed back and everything stays a lot simpler

PDDBTRF()

move the resulting block back to its location in main storage

PDLAHQR()

work is done on that.  at the end of the border, the data is
passed back and everything stays a lot simpler

PDSYTTRD()

this brings us back to the point at which mvr2 is called

PSDBTRF()

move the resulting block back to its location in main storage

PSLAHQR()

work is done on that.  at the end of the border, the data is
passed back and everything stays a lot simpler

PSSYTTRD()

this brings us back to the point at which mvr2 is called

PZDBTRF()

move the resulting block back to its location in main storage

PZHETTRD()

this brings us back to the point at which mvr2 is called

PZLAHQR()

work is done on that.  at the end of the border, the data is
passed back and everything stays a lot simpler

Backsolve

PCDBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PCDBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PCDBTRSV()

******************* Backsolve ************************************
*******************************************************************

PCDTSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PCDTTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PCDTTRSV()

******************* Backsolve ************************************
*******************************************************************

PCGBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PCGBTRF()

Backsolve left sid

PCGBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PCPBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PCPBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PCPBTRSV()

******************* Backsolve ************************************
*******************************************************************

PCPTSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PCPTTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PCPTTRSV()

******************* Backsolve ************************************
*******************************************************************

PDDBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PDDBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PDDBTRSV()

******************* Backsolve ************************************
*******************************************************************

PDDTSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PDDTTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PDDTTRSV()

******************* Backsolve ************************************
*******************************************************************

PDGBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PDGBTRF()

Backsolve left sid

PDGBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PDPBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PDPBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PDPBTRSV()

******************* Backsolve ************************************
*******************************************************************

PDPTSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PDPTTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PDPTTRSV()

******************* Backsolve ************************************
*******************************************************************

PSDBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PSDBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PSDBTRSV()

******************* Backsolve ************************************
*******************************************************************

PSDTSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PSDTTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PSDTTRSV()

******************* Backsolve ************************************
*******************************************************************

PSGBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PSGBTRF()

Backsolve left sid

PSGBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PSPBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PSPBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PSPBTRSV()

******************* Backsolve ************************************
*******************************************************************

PSPTSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PSPTTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PSPTTRSV()

******************* Backsolve ************************************
*******************************************************************

PZDBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PZDBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PZDBTRSV()

******************* Backsolve ************************************
*******************************************************************

PZDTSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PZDTTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PZDTTRSV()

******************* Backsolve ************************************
*******************************************************************

PZGBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PZGBTRF()

Backsolve left sid

PZGBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PZPBSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PZPBTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PZPBTRSV()

******************* Backsolve ************************************
*******************************************************************

PZPTSV()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PZPTTRS()

algorithm is used. for a linear system, a parallel front solve
followed by an analagous Backsolve, both using the structur
3) backsubsitution phase:

PZPTTRSV()

******************* Backsolve ************************************
*******************************************************************

Backsubsitution

PCDBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PCDBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PCDTSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PCDTTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PCGBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PCGBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PCPBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PCPBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PCPTSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PCPTTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PDDBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PDDBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PDDTSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PDDTTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PDGBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PDGBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PDPBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PDPBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PDPTSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PDPTTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PSDBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PSDBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PSDTSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PSDTTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PSGBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PSGBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PSPBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PSPBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PSPTSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PSPTTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PZDBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PZDBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PZDTSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PZDTTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PZGBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PZGBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PZPBSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PZPBTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PZPTSV()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

PZPTTRS()

of the factored matrix, are performed.
3) Backsubsitution phase
each processor in parallel.

backsubstitution

PCDBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PCDBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PCDTSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PCDTTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PCGBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PCGBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PCPBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PCPBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PCPTSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PCPTTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PDDBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PDDBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PDDTSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PDDTTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PDGBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PDGBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PDPBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PDPBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PDPTSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PDPTTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PSDBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PSDBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PSDTSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PSDTTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PSGBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PSGBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PSPBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PSPBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PSPTSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PSPTTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PZDBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PZDBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PZDTSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PZDTTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PZGBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PZGBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PZPBSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PZPBTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PZPTSV()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

PZPTTRS()

3) backsubsitution phase:
for a linear system, a local backsubstitution is performed o

backtransform

PCTREVC()

= 'b':  compute all right and/or left eigenvectors,
and backtransform them using the input matrice
= 's':  compute selected right and/or left eigenvectors,

PZTREVC()

= 'b':  compute all right and/or left eigenvectors,
and backtransform them using the input matrice
= 's':  compute selected right and/or left eigenvectors,

backward

PCGERFS()

pcgerfs improves the computed solution to a system of linear
equations and provides error bounds and backward error estimates fo

PCGESVX()

5. iterative refinement is applied to improve the computed solution
matrix and calculate error bounds and backward error estimate

PCLAPIV()

computes p*sub( a ).
= 'b' (backward) applies pivots backward from bottom o

PCLAPV2()

computes p * sub( a );
= 'b' (backward) applies pivots backward from bottom o

PCLARFB()

= 'f': q = h(1) h(2) . . . h(k) (forward)
= 'b': q = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PCLARFT()

= 'f': h = h(1) h(2) . . . h(k) (forward)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character*1

PCLARZB()

= 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PCLARZT()

= 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PCLASWP()

= 'f' (forward)
= 'b' (backward
rowcol  (global input) character

PCPORFS()

equations when the coefficient matrix is hermitian positive definite
and provides error bounds and backward error estimates for th

PCPOSVX()

5. iterative refinement is applied to improve the computed solution
matrix and calculate error bounds and backward error estimate

PCTREVC()

the algorithm used in this program is basically backward (forward
the code robust against possible overflow.  but scaling has not yet

PCTRRFS()

pctrrfs provides error bounds and backward error estimates for th
coefficient matrix.

PDGERFS()

pdgerfs improves the computed solution to a system of linear
equations and provides error bounds and backward error estimates fo

PDGESVX()

5. iterative refinement is applied to improve the computed solution
matrix and calculate error bounds and backward error estimate

PDLAPIV()

computes p*sub( a ).
= 'b' (backward) applies pivots backward from bottom o

PDLAPV2()

computes p * sub( a );
= 'b' (backward) applies pivots backward from bottom o

PDLARFB()

= 'f': q = h(1) h(2) . . . h(k) (forward)
= 'b': q = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PDLARFT()

= 'f': h = h(1) h(2) . . . h(k) (forward)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character*1

PDLARZB()

= 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PDLARZT()

= 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PDLASWP()

= 'f' (forward)
= 'b' (backward
rowcol  (global input) character

PDPORFS()

equations when the coefficient matrix is symmetric positive definite
and provides error bounds and backward error estimates for th

PDPOSVX()

5. iterative refinement is applied to improve the computed solution
matrix and calculate error bounds and backward error estimate

PDTRRFS()

pdtrrfs provides error bounds and backward error estimates for th
coefficient matrix.

PSGERFS()

psgerfs improves the computed solution to a system of linear
equations and provides error bounds and backward error estimates fo

PSGESVX()

5. iterative refinement is applied to improve the computed solution
matrix and calculate error bounds and backward error estimate

PSLAPIV()

computes p*sub( a ).
= 'b' (backward) applies pivots backward from bottom o

PSLAPV2()

computes p * sub( a );
= 'b' (backward) applies pivots backward from bottom o

PSLARFB()

= 'f': q = h(1) h(2) . . . h(k) (forward)
= 'b': q = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PSLARFT()

= 'f': h = h(1) h(2) . . . h(k) (forward)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character*1

PSLARZB()

= 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PSLARZT()

= 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PSLASWP()

= 'f' (forward)
= 'b' (backward
rowcol  (global input) character

PSPORFS()

equations when the coefficient matrix is symmetric positive definite
and provides error bounds and backward error estimates for th

PSPOSVX()

5. iterative refinement is applied to improve the computed solution
matrix and calculate error bounds and backward error estimate

PSTRRFS()

pstrrfs provides error bounds and backward error estimates for th
coefficient matrix.

PZGERFS()

pzgerfs improves the computed solution to a system of linear
equations and provides error bounds and backward error estimates fo

PZGESVX()

5. iterative refinement is applied to improve the computed solution
matrix and calculate error bounds and backward error estimate

PZLAPIV()

computes p*sub( a ).
= 'b' (backward) applies pivots backward from bottom o

PZLAPV2()

computes p * sub( a );
= 'b' (backward) applies pivots backward from bottom o

PZLARFB()

= 'f': q = h(1) h(2) . . . h(k) (forward)
= 'b': q = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PZLARFT()

= 'f': h = h(1) h(2) . . . h(k) (forward)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character*1

PZLARZB()

= 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PZLARZT()

= 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet)
= 'b': h = h(k) . . . h(2) h(1) (backward
storev  (global input) character

PZLASWP()

= 'f' (forward)
= 'b' (backward
rowcol  (global input) character

PZPORFS()

equations when the coefficient matrix is hermitian positive definite
and provides error bounds and backward error estimates for th

PZPOSVX()

5. iterative refinement is applied to improve the computed solution
matrix and calculate error bounds and backward error estimate

PZTREVC()

the algorithm used in this program is basically backward (forward
the code robust against possible overflow.  but scaling has not yet

PZTRRFS()

pztrrfs provides error bounds and backward error estimates for th
coefficient matrix.

bal

PCDBSV()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PCDBTRS()

trans   (global input) characte
= 'c':  solve with conjugate_transpose( a(1:n, ja:ja+n-1) );

PCDTSV()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PCDTTRS()

trans   (global input) characte
= 'c':  solve with conjugate_transpose( a(1:n, ja:ja+n-1) );

PCGBSV()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PCGBTRS()

trans   (global input) characte
= 'c':  solve with conjugate_transpose( a(1:n, ja:ja+n-1) );

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

PCHEEV()

--------------- -------------- --------------------------------------
dtype_a(global) desca( dtype_) the descriptor type
the blacs process grid a is distribu-

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()

pclacp3 is an auxiliary routine that copies from a global paralle
the entire submatrix that is copied gets placed on one node or

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()

pcmax1 computes the global index of the maximum element in absolut
in indx and the value is returned in amax,

PCPBSV()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

PCPBTRS()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

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()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

PCPTTRS()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

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()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PDDBTRS()

trans   (global input) characte
= 't' or 'c':  solve with a(1:n, ja:ja+n-1)^t;

PDDTSV()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PDDTTRS()

trans   (global input) characte
= 't' or 'c':  solve with a(1:n, ja:ja+n-1)^t;

PDGBSV()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PDGBTRS()

trans   (global input) characte
= 't' or 'c':  solve with a(1:n, ja:ja+n-1)^t;

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()

pdlacp3 is an auxiliary routine that copies from a global paralle
the entire submatrix that is copied gets placed on one node or

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()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

PDPBTRS()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

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()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PDPTTRS()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

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

PDSYEV()

--------------- -------------- --------------------------------------
dtype_a(global) desca( dtype_) the descriptor type
the blacs process grid a is distribu-

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()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PSDBTRS()

trans   (global input) characte
= 't' or 'c':  solve with a(1:n, ja:ja+n-1)^t;

PSDTSV()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PSDTTRS()

trans   (global input) characte
= 't' or 'c':  solve with a(1:n, ja:ja+n-1)^t;

PSGBSV()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PSGBTRS()

trans   (global input) characte
= 't' or 'c':  solve with a(1:n, ja:ja+n-1)^t;

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()

pslacp3 is an auxiliary routine that copies from a global paralle
the entire submatrix that is copied gets placed on one node or

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()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

PSPBTRS()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

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()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PSPTTRS()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

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

PSSYEV()

--------------- -------------- --------------------------------------
dtype_a(global) desca( dtype_) the descriptor type
the blacs process grid a is distribu-

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()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PZDBTRS()

trans   (global input) characte
= 'c':  solve with conjugate_transpose( a(1:n, ja:ja+n-1) );

PZDRSCL()

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

PZDTSV()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PZDTTRS()

trans   (global input) characte
= 'c':  solve with conjugate_transpose( a(1:n, ja:ja+n-1) );

PZGBSV()

n       (global input) intege
order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0.

PZGBTRS()

trans   (global input) characte
= 'c':  solve with conjugate_transpose( a(1:n, ja:ja+n-1) );

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

PZHEEV()

--------------- -------------- --------------------------------------
dtype_a(global) desca( dtype_) the descriptor type
the blacs process grid a is distribu-

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()

pzlacp3 is an auxiliary routine that copies from a global paralle
the entire submatrix that is copied gets placed on one node or

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()

pzmax1 computes the global index of the maximum element in absolut
in indx and the value is returned in amax,

PZPBSV()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

PZPBTRS()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

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()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

PZPTTRS()

uplo    (global input) characte
= 'l':  lower triangle of a(1:n, ja:ja+n-1) is stored.

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

balanced

PCHETTRD()

work required in updating the current column of a.  updating
the block column of a is reasonably load balanced wherea
processor column is involved).

PDSYTTRD()

work required in updating the current column of a.  updating
the block column of a is reasonably load balanced wherea
processor column is involved).

PSSYTTRD()

work required in updating the current column of a.  updating
the block column of a is reasonably load balanced wherea
processor column is involved).

PZHETTRD()

work required in updating the current column of a.  updating
the block column of a is reasonably load balanced wherea
processor column is involved).

band

CDBTF2()

cdbtrf computes an lu factorization of a real m-by-n band matrix 

CDBTRF()

of columns are jb, j2, j3. the superdiagonal elements of a13
and the subdiagonal elements of a31 lie outside the band

DDBTF2()

ddbtrf computes an lu factorization of a real m-by-n band matrix 

DDBTRF()

of columns are jb, j2, j3. the superdiagonal elements of a13
and the subdiagonal elements of a31 lie outside the band

SDBTF2()

sdbtrf computes an lu factorization of a real m-by-n band matrix 

SDBTRF()

of columns are jb, j2, j3. the superdiagonal elements of a13
and the subdiagonal elements of a31 lie outside the band

ZDBTF2()

zdbtrf computes an lu factorization of a real m-by-n band matrix 

ZDBTRF()

of columns are jb, j2, j3. the superdiagonal elements of a13
and the subdiagonal elements of a31 lie outside the band

banded

PCDBSV()

where a(1:n, ja:ja+n-1) is an n-by-n complex
banded diagonally dominant-like distribute

PCDBTRS()

a(1:n, ja:ja+n-1) is an n-by-n complex
banded diagonally dominant-like distribute

PCDTSV()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PCDTTRS()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PCGBSV()

where a(1:n, ja:ja+n-1) is an n-by-n complex
banded distribute

PCGBTRF()

furthermore, the elements in the same row are ldb=llda-1 apart
the complicated formulas are to cope with the banded

PCGBTRS()

a(1:n, ja:ja+n-1) is an n-by-n complex
banded distribute

PCPBSV()

where a(1:n, ja:ja+n-1) is an n-by-n complex
banded symmetric positive definite distribute

PCPBTRS()

a(1:n, ja:ja+n-1) is an n-by-n complex
banded symmetric positive definite distribute
depending on the value of uplo, a stores either u or l in the equn

PCPTSV()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PCPTTRS()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PDDBSV()

where a(1:n, ja:ja+n-1) is an n-by-n real
banded diagonally dominant-like distribute

PDDBTRS()

a(1:n, ja:ja+n-1) is an n-by-n real
banded diagonally dominant-like distribute

PDDTSV()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PDDTTRS()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PDGBSV()

where a(1:n, ja:ja+n-1) is an n-by-n real
banded distribute

PDGBTRF()

furthermore, the elements in the same row are ldb=llda-1 apart
the complicated formulas are to cope with the banded

PDGBTRS()

a(1:n, ja:ja+n-1) is an n-by-n real
banded distribute

PDPBSV()

where a(1:n, ja:ja+n-1) is an n-by-n real
banded symmetric positive definite distribute

PDPBTRS()

a(1:n, ja:ja+n-1) is an n-by-n real
banded symmetric positive definite distribute
depending on the value of uplo, a stores either u or l in the equn

PDPTSV()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PDPTTRS()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PSDBSV()

where a(1:n, ja:ja+n-1) is an n-by-n real
banded diagonally dominant-like distribute

PSDBTRS()

a(1:n, ja:ja+n-1) is an n-by-n real
banded diagonally dominant-like distribute

PSDTSV()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PSDTTRS()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PSGBSV()

where a(1:n, ja:ja+n-1) is an n-by-n real
banded distribute

PSGBTRF()

furthermore, the elements in the same row are ldb=llda-1 apart
the complicated formulas are to cope with the banded

PSGBTRS()

a(1:n, ja:ja+n-1) is an n-by-n real
banded distribute

PSPBSV()

where a(1:n, ja:ja+n-1) is an n-by-n real
banded symmetric positive definite distribute

PSPBTRS()

a(1:n, ja:ja+n-1) is an n-by-n real
banded symmetric positive definite distribute
depending on the value of uplo, a stores either u or l in the equn

PSPTSV()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PSPTTRS()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PZDBSV()

where a(1:n, ja:ja+n-1) is an n-by-n complex
banded diagonally dominant-like distribute

PZDBTRS()

a(1:n, ja:ja+n-1) is an n-by-n complex
banded diagonally dominant-like distribute

PZDTSV()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PZDTTRS()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PZGBSV()

where a(1:n, ja:ja+n-1) is an n-by-n complex
banded distribute

PZGBTRF()

furthermore, the elements in the same row are ldb=llda-1 apart
the complicated formulas are to cope with the banded

PZGBTRS()

a(1:n, ja:ja+n-1) is an n-by-n complex
banded distribute

PZPBSV()

where a(1:n, ja:ja+n-1) is an n-by-n complex
banded symmetric positive definite distribute

PZPBTRS()

a(1:n, ja:ja+n-1) is an n-by-n complex
banded symmetric positive definite distribute
depending on the value of uplo, a stores either u or l in the equn

PZPTSV()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

PZPTTRS()

the best algorithm for solving banded and tridiagonal linear system
currently, only algorithms designed for the case n/p >> bw are

bandwidth

PCDBSV()

banded diagonally dominant-like distributed
matrix with bandwidth bwl, bwu
gaussian elimination without pivoting

PCDBTRS()

banded diagonally dominant-like distributed
matrix with bandwidth bwl, bwu
routine pcdbtrf must be called first.

PCDTSV()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PCDTTRS()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PCGBSV()

banded distributed
matrix with bandwidth bwl, bwu
gaussian elimination with pivoting

PCGBTRF()

lbwl, lbwu: lower and upper bandwidth of local solve
lm is the number of rows which is usually nb except for

PCGBTRS()

banded distributed
matrix with bandwidth bwl, bwu
routine pcgbtrf must be called first.

PCPBSV()

banded symmetric positive definite distributed
matrix with bandwidth bw
cholesky factorization is used to factor a reordering of

PCPBTRS()

banded symmetric positive definite distributed
matrix with bandwidth bw
a(1:n, ja:ja+n-1) = u'*u or l*l' as computed by pcpbtrf.

PCPTSV()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PCPTTRS()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PDDBSV()

banded diagonally dominant-like distributed
matrix with bandwidth bwl, bwu
gaussian elimination without pivoting

PDDBTRS()

banded diagonally dominant-like distributed
matrix with bandwidth bwl, bwu
routine pddbtrf must be called first.

PDDTSV()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PDDTTRS()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PDGBSV()

banded distributed
matrix with bandwidth bwl, bwu
gaussian elimination with pivoting

PDGBTRF()

lbwl, lbwu: lower and upper bandwidth of local solve
lm is the number of rows which is usually nb except for

PDGBTRS()

banded distributed
matrix with bandwidth bwl, bwu
routine pdgbtrf must be called first.

PDPBSV()

banded symmetric positive definite distributed
matrix with bandwidth bw
cholesky factorization is used to factor a reordering of

PDPBTRS()

banded symmetric positive definite distributed
matrix with bandwidth bw
a(1:n, ja:ja+n-1) = u'*u or l*l' as computed by pdpbtrf.

PDPTSV()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PDPTTRS()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PSDBSV()

banded diagonally dominant-like distributed
matrix with bandwidth bwl, bwu
gaussian elimination without pivoting

PSDBTRS()

banded diagonally dominant-like distributed
matrix with bandwidth bwl, bwu
routine psdbtrf must be called first.

PSDTSV()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PSDTTRS()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PSGBSV()

banded distributed
matrix with bandwidth bwl, bwu
gaussian elimination with pivoting

PSGBTRF()

lbwl, lbwu: lower and upper bandwidth of local solve
lm is the number of rows which is usually nb except for

PSGBTRS()

banded distributed
matrix with bandwidth bwl, bwu
routine psgbtrf must be called first.

PSPBSV()

banded symmetric positive definite distributed
matrix with bandwidth bw
cholesky factorization is used to factor a reordering of

PSPBTRS()

banded symmetric positive definite distributed
matrix with bandwidth bw
a(1:n, ja:ja+n-1) = u'*u or l*l' as computed by pspbtrf.

PSPTSV()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PSPTTRS()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PZDBSV()

banded diagonally dominant-like distributed
matrix with bandwidth bwl, bwu
gaussian elimination without pivoting

PZDBTRS()

banded diagonally dominant-like distributed
matrix with bandwidth bwl, bwu
routine pzdbtrf must be called first.

PZDTSV()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PZDTTRS()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PZGBSV()

banded distributed
matrix with bandwidth bwl, bwu
gaussian elimination with pivoting

PZGBTRF()

lbwl, lbwu: lower and upper bandwidth of local solve
lm is the number of rows which is usually nb except for

PZGBTRS()

banded distributed
matrix with bandwidth bwl, bwu
routine pzgbtrf must be called first.

PZPBSV()

banded symmetric positive definite distributed
matrix with bandwidth bw
cholesky factorization is used to factor a reordering of

PZPBTRS()

banded symmetric positive definite distributed
matrix with bandwidth bw
a(1:n, ja:ja+n-1) = u'*u or l*l' as computed by pzpbtrf.

PZPTSV()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

PZPTTRS()

the best algorithm for solving banded and tridiagonal linear systems
depends on a variety of parameters, especially the bandwidth
implemented. these go by many names, including divide and conquer,

bandwidths

PCDBTRF()

size of separator blocks is maximum of bandwidths

PCDBTRSV()

size of separator blocks is maximum of bandwidths

PDDBTRF()

size of separator blocks is maximum of bandwidths

PDDBTRSV()

size of separator blocks is maximum of bandwidths

PSDBTRF()

size of separator blocks is maximum of bandwidths

PSDBTRSV()

size of separator blocks is maximum of bandwidths

PZDBTRF()

size of separator blocks is maximum of bandwidths

PZDBTRSV()

size of separator blocks is maximum of bandwidths

base

PDLAMCH()

= 's' or 's ,   pdlamch := sfmin
= 'b' or 'b',   pdlamch := base
= 'n' or 'n',   pdlamch := t

PSLAMCH()

= 's' or 's ,   pslamch := sfmin
= 'b' or 'b',   pslamch := base
= 'n' or 'n',   pslamch := t

Based

PCGBTRS()

and marbwus hegland, australian natonal university. feb., 1997.
Based on code written by    : peter arbenz, eth zurich, 1996
=====================================================================

PCHENGST()

pchengst performs the same function as pchegst, but is Based o
triangular solves (the basis of pchengst).

PCLAHQR()

find a new nbulge Based on the bulges we have

PCLAQGE()

thresh is a threshold value used to decide if row or column scaling
should be done Based on the ratio of the row or column scalin
colcnd < thresh, column scaling is done.

PCLAQSY()

thresh is a threshold value used to decide if scaling should be done
Based on the ratio of the scaling factors.  if scond < thresh

PCMAX1()

Based on pcamax from level 1 pblas. the change is to use th

PDGBTRS()

and markus hegland, australian national university. feb., 1997.
Based on code written by    : peter arbenz, eth zurich, 1996
eth, zurich.

PDLAQGE()

thresh is a threshold value used to decide if row or column scaling
should be done Based on the ratio of the row or column scalin
colcnd < thresh, column scaling is done.

PDLAQSY()

thresh is a threshold value used to decide if scaling should be done
Based on the ratio of the scaling factors.  if scond < thresh

PDSYNGST()

pdsyngst performs the same function as pdhegst, but is Based o
triangular solves (the basis of pdsyngst).

PDZSUM1()

Based on pdzasum from the level 1 pblas. the change i

PSCSUM1()

Based on pscasum from the level 1 pblas. the change i

PSGBTRS()

and markus hegland, australian national university. feb., 1997.
Based on code written by    : peter arbenz, eth zurich, 1996
eth, zurich.

PSLAQGE()

thresh is a threshold value used to decide if row or column scaling
should be done Based on the ratio of the row or column scalin
colcnd < thresh, column scaling is done.

PSLAQSY()

thresh is a threshold value used to decide if scaling should be done
Based on the ratio of the scaling factors.  if scond < thresh

PSSYNGST()

pssyngst performs the same function as pshegst, but is Based o
triangular solves (the basis of pssyngst).

PZGBTRS()

and marbwus hegland, australian natonal university. feb., 1997.
Based on code written by    : peter arbenz, eth zurich, 1996
=====================================================================

PZHENGST()

pzhengst performs the same function as pzhegst, but is Based o
triangular solves (the basis of pzhengst).

PZLAHQR()

find a new nbulge Based on the bulges we have

PZLAQGE()

thresh is a threshold value used to decide if row or column scaling
should be done Based on the ratio of the row or column scalin
colcnd < thresh, column scaling is done.

PZLAQSY()

thresh is a threshold value used to decide if scaling should be done
Based on the ratio of the scaling factors.  if scond < thresh

PZMAX1()

Based on pzamax from level 1 pblas. the change is to use th

basic

PCDBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PCDBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PCDTSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PCDTTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PCGBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PCGBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PCLASSQ()

on entry, the value  sumsq  in the equation above.
on exit, sumsq is overwritten with  smsq , the basic sum o

PCPBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PCPBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PCPTSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PCPTTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PDDBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PDDBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PDDTSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PDDTTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PDGBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PDGBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PDLASSQ()

on entry, the value  sumsq  in the equation above.
on exit, sumsq is overwritten with  smsq , the basic sum o

PDPBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PDPBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PDPTSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PDPTTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PSDBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PSDBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PSDTSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PSDTTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PSGBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PSGBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PSLASSQ()

on entry, the value  sumsq  in the equation above.
on exit, sumsq is overwritten with  smsq , the basic sum o

PSPBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PSPBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PSPTSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PSPTTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PZDBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PZDBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PZDTSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PZDTTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PZGBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PZGBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PZLASSQ()

on entry, the value  sumsq  in the equation above.
on exit, sumsq is overwritten with  smsq , the basic sum o

PZPBSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PZPBTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the banded matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PZPTSV()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

PZPTTRS()

with columns atomic and rows divided amongst the processes.
the basic algorithm divides the tridiagonal matrix up int
and then proceeds in 2 phases for the factorization or 3 for the

basically

PCLASMSUB()

this code is basically a parallelization of the following sni

PCTREVC()

the algorithm used in this program is basically backward (forward
the code robust against possible overflow.  but scaling has not yet

PDLASMSUB()

this code is basically a parallelization of the following sni

PSLASMSUB()

this code is basically a parallelization of the following sni

PZLASMSUB()

this code is basically a parallelization of the following sni

PZTREVC()

the algorithm used in this program is basically backward (forward
the code robust against possible overflow.  but scaling has not yet

basis

PCHENGST()

rank 2k updates, which are faster and more scalable than
triangular solves (the basis of pchengst)
pchengst calls pchegst when uplo='u', hence pchengst provides

PDSYNGST()

rank 2k updates, which are faster and more scalable than
triangular solves (the basis of pdsyngst)
pdsyngst calls pdhegst when uplo='u', hence pdhengst provides

PSSYNGST()

rank 2k updates, which are faster and more scalable than
triangular solves (the basis of pssyngst)
pssyngst calls pshegst when uplo='u', hence pshengst provides

PZHENGST()

rank 2k updates, which are faster and more scalable than
triangular solves (the basis of pzhengst)
pzhengst calls pzhegst when uplo='u', hence pzhengst provides

because

CDBTF2()

+ need not be set on entry, but are required by the routine to store
elements of u, because of fill-in resulting from the ro

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 

CLAMSH()

(nbulge > 1) and the first shift is starting in the middle of an
unreduced hessenberg matrix because of two or more consecutiv

DDBTF2()

+ need not be set on entry, but are required by the routine to store
elements of u, because of fill-in resulting from the ro

DLAMSH ()

(nbulge > 1) and the first shift is starting in the middle of an
unreduced hessenberg matrix because of two or more consecutive smal

PCDTSV()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PCDTTRS()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PCHEEV()

only spot checks of the consistency of the eigenvalues across the
different processes.  because of this, it is possible that 
messages.

PCHEEVX()

to one or more clusters of eigenvalues could not be
reorthogonalized because of insufficient workspace
iclustr.

PCHEGVX()

to one or more clusters of eigenvalues could not be
reorthogonalized because of insufficient workspace
iclustr.

PCLACGV()

because vectors may be viewed as a subclass of matrices, 

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 

PCLARFG()

because vectors may be viewed as a subclass of matrices, 

PCLASSQ()

because vectors may be viewed as a subclass of matrices, 

PCMAX1()

because vectors may be viewed as a subclass of matrices, 

PCPTSV()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PCPTTRS()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PCSRSCL()

because vectors may be seen as particular matrices, a distribute

PCTRRFS()

means before entering this routine.  pctrrfs does not do iterative
refinement because doing so cannot improve the backward error
notes

PDDTSV()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PDDTTRS()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PDLABAD()

and redefine the underflow and overflow limits to be the square roots
of the values computed by pdlamch.  this subroutine is needed because
the exponent range, as is found on a cray.

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 

PDLARFG()

because vectors may be viewed as a subclass of matrices, 

PDLASSQ()

because vectors may be viewed as a subclass of matrices, 

PDPTSV()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PDPTTRS()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PDRSCL()

because vectors may be seen as particular matrices, a distribute

PDSYEV()

no checks for consistency of the eigenvalues or eigenvectors across
the different processes.  because of this, it is possible that 
messages.

PDSYEVD()

no checks for consistency of the eigenvalues or eigenvectors across
the different processes.  because of this, it is possible that 
messages.

PDSYEVX()

to one or more clusters of eigenvalues could not be
reorthogonalized because of insufficient workspace
iclustr.

PDSYGVX()

to one or more clusters of eigenvalues could not be
reorthogonalized because of insufficient workspace
iclustr.

PDTRRFS()

means before entering this routine.  pdtrrfs does not do iterative
refinement because doing so cannot improve the backward error
notes

PDZSUM1()

because vectors may be viewed as a subclass of matrices, 

PSCSUM1()

because vectors may be viewed as a subclass of matrices, 

PSDTSV()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PSDTTRS()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PSLABAD()

and redefine the underflow and overflow limits to be the square roots
of the values computed by pslamch.  this subroutine is needed because
the exponent range, as is found on a cray.

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 

PSLARFG()

because vectors may be viewed as a subclass of matrices, 

PSLASSQ()

because vectors may be viewed as a subclass of matrices, 

PSPTSV()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PSPTTRS()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PSRSCL()

because vectors may be seen as particular matrices, a distribute

PSSYEV()

no checks for consistency of the eigenvalues or eigenvectors across
the different processes.  because of this, it is possible that 
messages.

PSSYEVD()

no checks for consistency of the eigenvalues or eigenvectors across
the different processes.  because of this, it is possible that 
messages.

PSSYEVX()

to one or more clusters of eigenvalues could not be
reorthogonalized because of insufficient workspace
iclustr.

PSSYGVX()

to one or more clusters of eigenvalues could not be
reorthogonalized because of insufficient workspace
iclustr.

PSTRRFS()

means before entering this routine.  pstrrfs does not do iterative
refinement because doing so cannot improve the backward error
notes

PZDRSCL()

because vectors may be seen as particular matrices, a distribute

PZDTSV()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PZDTTRS()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PZHEEV()

only spot checks of the consistency of the eigenvalues across the
different processes.  because of this, it is possible that 
messages.

PZHEEVX()

to one or more clusters of eigenvalues could not be
reorthogonalized because of insufficient workspace
iclustr.

PZHEGVX()

to one or more clusters of eigenvalues could not be
reorthogonalized because of insufficient workspace
iclustr.

PZLACGV()

because vectors may be viewed as a subclass of matrices, 

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 

PZLARFG()

because vectors may be viewed as a subclass of matrices, 

PZLASSQ()

because vectors may be viewed as a subclass of matrices, 

PZMAX1()

because vectors may be viewed as a subclass of matrices, 

PZPTSV()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PZPTTRS()

we require that the distributed vectors storing the diagonals of a
tridiagonal matrix be aligned with each other. because of this, 
of all diagonals simultaneously.

PZTRRFS()

means before entering this routine.  pztrrfs does not do iterative
refinement because doing so cannot improve the backward error
notes

SDBTF2()

+ need not be set on entry, but are required by the routine to store
elements of u, because of fill-in resulting from the ro

SLAMSH ()

(nbulge > 1) and the first shift is starting in the middle of an
unreduced hessenberg matrix because of two or more consecutive smal

ZDBTF2()

+ need not be set on entry, but are required by the routine to store
elements of u, because of fill-in resulting from the ro

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 

ZLAMSH()

(nbulge > 1) and the first shift is starting in the middle of an
unreduced hessenberg matrix because of two or more consecutiv

become

CLAHQR2()

submatrix of order 1 or 2 splits off at the bottom because a
subdiagonal element has become negligible

PCLAHQR()

submatrix of order 1 or 2 splits off at the bottom because a
subdiagonal element has become negligible

PDLAHQR()

submatrix of order 1 or 2 splits off at the bottom because a
subdiagonal element has become negligible

PSLAHQR()

submatrix of order 1 or 2 splits off at the bottom because a
subdiagonal element has become negligible

PZLAHQR()

submatrix of order 1 or 2 splits off at the bottom because a
subdiagonal element has become negligible

ZLAHQR2()

submatrix of order 1 or 2 splits off at the bottom because a
subdiagonal element has become negligible

been

CDBTF2()

> 0: if info = +i, u(i,i) is exactly zero. the factorization
has been completed, but the factor u is exactl
to solve a system of equations.

CDBTRF()

j2 and j3 are computed after ju has been updated
factorize the current block of jb columns

CDTTRF()

> 0:  if info = i, u(i,i) is exactly zero. the factorization
has been completed, but the factor u is exactl
to solve a system of equations.

CSTEQR2()

this is the lookahead loop, going until we have
convergence or too many steps have been taken

DDBTF2()

> 0: if info = +i, u(i,i) is exactly zero. the factorization
has been completed, but the factor u is exactl
to solve a system of equations.

DDBTRF()

j2 and j3 are computed after ju has been updated
factorize the current block of jb columns

DDTTRF()

> 0:  if info = i, u(i,i) is exactly zero. the factorization
has been completed, but the factor u is exactl
to solve a system of equations.

DLASORTE()

on entry, a matrix already in schur form.
on exit, the diagonal blocks of s have been rewritten to pai
similar to the input.

PCDBTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PCDTTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PCGESV()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
computed.

PCGESVX()

if equed is not 'n', the matrix
a(ia:ia+n-1,ja:ja+n-1) has been equilibrated wit
a(ia:ia+n-1,ja:ja+n-1), af(iaf:iaf+n-1,jaf:jaf+n-1),

PCGETF2()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
it is used to solve a system of equations.

PCGETRF()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
it is used to solve a system of equations.

PCHEGS2()

sub( b ) must have been previously factorized as u**h*u or l*l**h b

PCHEGST()

sub( b ) must have been previously factorized as u**h*u or l*l**h b

PCHENGST()

sub( b ) must have been previously factorized as u**h*u or l*l**h b

PCLACON()

the serial version clacon has been contributed by nick higham
march 16, 1988.

PCLAMR1D()

pclamr1d has not been tested except withint the contect o

PCLANHE()

irsr0   : pointer to part of work used to store the rowsums after
they have been transposed to be along a process ro

PCLANSY()

irsr0   : pointer to part of work used to store the rowsums after
they have been transposed to be along a process ro

PCLAQGE()

= 'n':  no equilibration
= 'r':  row equilibration, i.e., sub( a ) has been pre
= 'c':  column equilibration, i.e., sub( a ) has been post-

PCLAQSY()

= 'n':  no equilibration.
= 'y':  equilibration was done, i.e., sub( a ) has been re
diag(sr(ia:ia+n-1)) * sub( a ) * diag(sc(ja:ja+n-1)).

PCLASSQ()

on exit, sumsq is overwritten with  smsq , the basic sum of
squares from which  scl  has been factored out
=====================================================================

PCLASWP()

sub( a ). this routine assumes that the pivoting information has
already been broadcast along the process row or column
same mb (or nb) block.  if you want to pivot a full matrix, use

PCLATRD()

triangular part is not referenced.
on exit, if uplo = 'u', the last nb columns have been reduce
the diagonal elements of sub( a ); the elements above the

PCPBTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PCPOSV()

the factorization could not be completed, and the
solution has not been computed
=====================================================================

PCPOSVX()

= 'f':  on entry, af contains the factored form of a.
if equed = 'y', the matrix a has been equilibrate
be modified.

PCPTTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PCTREVC()

the code robust against possible overflow.  but scaling has not yet
been implemented in pclattrs which is called by this routine to solv

PCTRTRS()

zero, indicating that the submatrix is singular and the
solutions x have not been computed
=====================================================================

PCUNMBR()

if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by-
if nq >= k, q = h(1) h(2) . . . h(k);

PDDBTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PDDTTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PDGESV()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
computed.

PDGESVX()

if equed is not 'n', the matrix
a(ia:ia+n-1,ja:ja+n-1) has been equilibrated wit
a(ia:ia+n-1,ja:ja+n-1), af(iaf:iaf+n-1,jaf:jaf+n-1),

PDGETF2()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
it is used to solve a system of equations.

PDGETRF()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
it is used to solve a system of equations.

PDLACON()

the serial version dlacon has been contributed by nick higham
march 16, 1988.

PDLAED0()

on entry, the subdiagonal elements of the tridiagonal matrix.
on exit, e has been destroyed
q       (local output) double precision array,

PDLAED2()

being recombined.
on exit, rho has been modified to the value required b

PDLAED3()

being recombined.
on exit, rho has been modified to the value required b

PDLAMR1D()

pdlamr1d has not been tested except withint the contect o

PDLANSY()

irsr0   : pointer to part of work used to store the rowsums after
they have been transposed to be along a process ro

PDLAQGE()

= 'n':  no equilibration
= 'r':  row equilibration, i.e., sub( a ) has been pre
= 'c':  column equilibration, i.e., sub( a ) has been post-

PDLAQSY()

= 'n':  no equilibration.
= 'y':  equilibration was done, i.e., sub( a ) has been re
diag(sr(ia:ia+n-1)) * sub( a ) * diag(sc(ja:ja+n-1)).

PDLASSQ()

on exit, sumsq is overwritten with  smsq , the basic sum of
squares from which  scl  has been factored out
=====================================================================

PDLASWP()

sub( a ). this routine assumes that the pivoting information has
already been broadcast along the process row or column
same mb (or nb) block.  if you want to pivot a full matrix, use

PDLATRD()

triangular part is not referenced.
on exit, if uplo = 'u', the last nb columns have been reduce
the diagonal elements of sub( a ); the elements above the

PDORMBR()

if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by-
if nq >= k, q = h(1) h(2) . . . h(k);

PDPBTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PDPOSV()

the factorization could not be completed, and the
solution has not been computed
=====================================================================

PDPOSVX()

= 'f':  on entry, af contains the factored form of a.
if equed = 'y', the matrix a has been equilibrate
be modified.

PDPTTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PDSTEBZ()

the absolute tolerance for the eigenvalues.  an eigenvalue
(or cluster) is considered to be located if it has been
less.  if abstol is less than or equal to zero, then ulp*|t|

PDSTEDC()

on entry, the subdiagonal elements of the tridiagonal matrix.
on exit, e has been destroyed
q       (local output) double precision array,

PDSYGS2()

sub( b ) must have been previously factorized as u**t*u or l*l**t b

PDSYGST()

sub( b ) must have been previously factorized as u**t*u or l*l**t b

PDSYNGST()

sub( b ) must have been previously factorized as u**h*u or l*l**h b

PDTRTRS()

zero, indicating that the submatrix is singular and the
solutions x have not been computed
=====================================================================

PJLAENV()

the following conventions have been used when calling pjlaenv fro
1)  opts is a concatenation of all of the character options to

PSDBTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PSDTTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PSGESV()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
computed.

PSGESVX()

if equed is not 'n', the matrix
a(ia:ia+n-1,ja:ja+n-1) has been equilibrated wit
a(ia:ia+n-1,ja:ja+n-1), af(iaf:iaf+n-1,jaf:jaf+n-1),

PSGETF2()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
it is used to solve a system of equations.

PSGETRF()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
it is used to solve a system of equations.

PSLACON()

the serial version slacon has been contributed by nick higham
march 16, 1988.

PSLAED0()

on entry, the subdiagonal elements of the tridiagonal matrix.
on exit, e has been destroyed
q       (local output) real array,

PSLAED2()

being recombined.
on exit, rho has been modified to the value required b

PSLAED3()

being recombined.
on exit, rho has been modified to the value required b

PSLAMR1D()

pslamr1d has not been tested except withint the contect o

PSLANSY()

irsr0   : pointer to part of work used to store the rowsums after
they have been transposed to be along a process ro

PSLAQGE()

= 'n':  no equilibration
= 'r':  row equilibration, i.e., sub( a ) has been pre
= 'c':  column equilibration, i.e., sub( a ) has been post-

PSLAQSY()

= 'n':  no equilibration.
= 'y':  equilibration was done, i.e., sub( a ) has been re
diag(sr(ia:ia+n-1)) * sub( a ) * diag(sc(ja:ja+n-1)).

PSLASSQ()

on exit, sumsq is overwritten with  smsq , the basic sum of
squares from which  scl  has been factored out
=====================================================================

PSLASWP()

sub( a ). this routine assumes that the pivoting information has
already been broadcast along the process row or column
same mb (or nb) block.  if you want to pivot a full matrix, use

PSLATRD()

triangular part is not referenced.
on exit, if uplo = 'u', the last nb columns have been reduce
the diagonal elements of sub( a ); the elements above the

PSORMBR()

if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by-
if nq >= k, q = h(1) h(2) . . . h(k);

PSPBTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PSPOSV()

the factorization could not be completed, and the
solution has not been computed
=====================================================================

PSPOSVX()

= 'f':  on entry, af contains the factored form of a.
if equed = 'y', the matrix a has been equilibrate
be modified.

PSPTTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PSSTEBZ()

the absolute tolerance for the eigenvalues.  an eigenvalue
(or cluster) is considered to be located if it has been
less.  if abstol is less than or equal to zero, then ulp*|t|

PSSTEDC()

on entry, the subdiagonal elements of the tridiagonal matrix.
on exit, e has been destroyed
q       (local output) real array,

PSSYGS2()

sub( b ) must have been previously factorized as u**t*u or l*l**t b

PSSYGST()

sub( b ) must have been previously factorized as u**t*u or l*l**t b

PSSYNGST()

sub( b ) must have been previously factorized as u**h*u or l*l**h b

PSTRTRS()

zero, indicating that the submatrix is singular and the
solutions x have not been computed
=====================================================================

PZDBTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PZDTTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PZGESV()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
computed.

PZGESVX()

if equed is not 'n', the matrix
a(ia:ia+n-1,ja:ja+n-1) has been equilibrated wit
a(ia:ia+n-1,ja:ja+n-1), af(iaf:iaf+n-1,jaf:jaf+n-1),

PZGETF2()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
it is used to solve a system of equations.

PZGETRF()

> 0:  if info = k, u(ia+k-1,ja+k-1) is exactly zero.
the factorization has been completed, but the factor 
it is used to solve a system of equations.

PZHEGS2()

sub( b ) must have been previously factorized as u**h*u or l*l**h b

PZHEGST()

sub( b ) must have been previously factorized as u**h*u or l*l**h b

PZHENGST()

sub( b ) must have been previously factorized as u**h*u or l*l**h b

PZLACON()

the serial version zlacon has been contributed by nick higham
march 16, 1988.

PZLAMR1D()

pzlamr1d has not been tested except withint the contect o

PZLANHE()

irsr0   : pointer to part of work used to store the rowsums after
they have been transposed to be along a process ro

PZLANSY()

irsr0   : pointer to part of work used to store the rowsums after
they have been transposed to be along a process ro

PZLAQGE()

= 'n':  no equilibration
= 'r':  row equilibration, i.e., sub( a ) has been pre
= 'c':  column equilibration, i.e., sub( a ) has been post-

PZLAQSY()

= 'n':  no equilibration.
= 'y':  equilibration was done, i.e., sub( a ) has been re
diag(sr(ia:ia+n-1)) * sub( a ) * diag(sc(ja:ja+n-1)).

PZLASSQ()

on exit, sumsq is overwritten with  smsq , the basic sum of
squares from which  scl  has been factored out
=====================================================================

PZLASWP()

sub( a ). this routine assumes that the pivoting information has
already been broadcast along the process row or column
same mb (or nb) block.  if you want to pivot a full matrix, use

PZLATRD()

triangular part is not referenced.
on exit, if uplo = 'u', the last nb columns have been reduce
the diagonal elements of sub( a ); the elements above the

PZPBTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PZPOSV()

the factorization could not be completed, and the
solution has not been computed
=====================================================================

PZPOSVX()

= 'f':  on entry, af contains the factored form of a.
if equed = 'y', the matrix a has been equilibrate
be modified.

PZPTTRSV()

******************************
reduced system has been solved, communicate solutions to neares

PZTREVC()

the code robust against possible overflow.  but scaling has not yet
been implemented in pzlattrs which is called by this routine to solv

PZTRTRS()

zero, indicating that the submatrix is singular and the
solutions x have not been computed
=====================================================================

PZUNMBR()

if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by-
if nq >= k, q = h(1) h(2) . . . h(k);

SDBTF2()

> 0: if info = +i, u(i,i) is exactly zero. the factorization
has been completed, but the factor u is exactl
to solve a system of equations.

SDBTRF()

j2 and j3 are computed after ju has been updated
factorize the current block of jb columns

SDTTRF()

> 0:  if info = i, u(i,i) is exactly zero. the factorization
has been completed, but the factor u is exactl
to solve a system of equations.

SLASORTE()

on entry, a matrix already in schur form.
on exit, the diagonal blocks of s have been rewritten to pai
similar to the input.

ZDBTF2()

> 0: if info = +i, u(i,i) is exactly zero. the factorization
has been completed, but the factor u is exactl
to solve a system of equations.

ZDBTRF()

j2 and j3 are computed after ju has been updated
factorize the current block of jb columns

ZDTTRF()

> 0:  if info = i, u(i,i) is exactly zero. the factorization
has been completed, but the factor u is exactl
to solve a system of equations.

ZSTEQR2()

this is the lookahead loop, going until we have
convergence or too many steps have been taken

before

CTRMVT()

t      - complex array of dimension ( ldt, n ).
before entry with  uplo = 'u' or 'u', the leading n by 
triangular matrix and the strictly lower triangular part of

DTRMVT()

t      - double precision array of dimension ( ldt, n ).
before entry with  uplo = 'u' or 'u', the leading n by 
triangular matrix and the strictly lower triangular part of

PCDBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PCDBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PCDTSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PCDTTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PCGBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PCGBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PCGESVX()

trans = 't' or 'c') so that it solves the original system
before equilibration
arguments

PCHEEVX()

insufficient space and pcheevx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PCHEGVX()

insufficient space and pchegvx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PCLARFG()

contains the local pieces of the distributed vector sub( x ).
before entry, the incremented array sub( x ) must contai

PCLATTRS()

otherwise, scale column of a by uscal before do

PCPBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PCPBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PCPOSVX()

6. if equilibration was used, the matrix x is premultiplied by
diag(sr) so that it solves the original system before

PCPTSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PCPTTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PCTRRFS()

the solution matrix x must be computed by pctrtrs or some other
means before entering this routine.  pctrrfs does not do iterativ

PDDBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PDDBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PDDTSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PDDTTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PDGBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PDGBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PDGESVX()

trans = 't' or 'c') so that it solves the original system
before equilibration
arguments

PDLAMCH()

rnd   = 1.0 when rounding occurs in addition, 0.0 otherwise
emin  = minimum exponent before (gradual) underflo
emax  = largest exponent before overflow

PDLARFG()

contains the local pieces of the distributed vector sub( x ).
before entry, the incremented array sub( x ) must contai

PDPBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PDPBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PDPOSVX()

6. if equilibration was used, the matrix x is premultiplied by
diag(sr) so that it solves the original system before

PDPTSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PDPTTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PDSYEVX()

insufficient space and pdsyevx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PDSYGVX()

insufficient space and pdsygvx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PDTRRFS()

the solution matrix x must be computed by pdtrtrs or some other
means before entering this routine.  pdtrrfs does not do iterativ

PSDBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PSDBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PSDTSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PSDTTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PSGBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PSGBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PSGESVX()

trans = 't' or 'c') so that it solves the original system
before equilibration
arguments

PSLAMCH()

rnd   = 1.0 when rounding occurs in addition, 0.0 otherwise
emin  = minimum exponent before (gradual) underflo
emax  = largest exponent before overflow

PSLARFG()

contains the local pieces of the distributed vector sub( x ).
before entry, the incremented array sub( x ) must contai

PSPBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PSPBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PSPOSVX()

6. if equilibration was used, the matrix x is premultiplied by
diag(sr) so that it solves the original system before

PSPTSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PSPTTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PSSYEVX()

insufficient space and pssyevx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PSSYGVX()

insufficient space and pssygvx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PSTRRFS()

the solution matrix x must be computed by pstrtrs or some other
means before entering this routine.  pstrrfs does not do iterativ

PZDBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PZDBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PZDTSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PZDTTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PZGBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PZGBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PZGESVX()

trans = 't' or 'c') so that it solves the original system
before equilibration
arguments

PZHEEVX()

insufficient space and pzheevx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PZHEGVX()

insufficient space and pzhegvx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PZLARFG()

contains the local pieces of the distributed vector sub( x ).
before entry, the incremented array sub( x ) must contai

PZLATTRS()

otherwise, scale column of a by uscal before do

PZPBSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PZPBTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PZPOSVX()

6. if equilibration was used, the matrix x is premultiplied by
diag(sr) so that it solves the original system before

PZPTSV()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PZPTTRS()

to opposite requirements for the orientation of the blacs grid,
and as noted before, the *same* blacs context must be used i

PZTRRFS()

the solution matrix x must be computed by pztrtrs or some other
means before entering this routine.  pztrrfs does not do iterativ

STRMVT()

t      - real array of dimension ( ldt, n ).
before entry with  uplo = 'u' or 'u', the leading n by 
triangular matrix and the strictly lower triangular part of

ZTRMVT()

t      - complex*16 array of dimension ( ldt, n ).
before entry with  uplo = 'u' or 'u', the leading n by 
triangular matrix and the strictly lower triangular part of

Begin

PCDBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PCDBTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PCDTTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PCDTTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PCGBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PCPBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PCPBTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PCPTTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PCPTTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PDDBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PDDBTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PDDTTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PDDTTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PDGBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PDPBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PDPBTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PDPTTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PDPTTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PSDBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PSDBTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PSDTTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PSDTTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PSGBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PSPBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PSPBTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PSPTTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PSPTTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PZDBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PZDBTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PZDTTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PZDTTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PZGBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PZPBTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PZPBTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PZPTTRF()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

PZPTTRSV()

adjust addressing into matrix space to properly get into
the Beginning part of the relevant dat

beginning

PCDBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PCDBTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PCDTTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PCDTTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PCGBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PCHEEV()

ia      (global input) integer
a's global row index, which points to the beginning of th

PCHEEVD()

ia      (global input) integer
a's global row index, which points to the beginning of th

PCHEEVX()

ia      (global input) integer
a's global row index, which points to the beginning of th

PCHEGS2()

ia      (global input) integer
a's global row index, which points to the beginning of th

PCHEGST()

ia      (global input) integer
a's global row index, which points to the beginning of th

PCHEGVX()

insufficient space and pchegvx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PCHENGST()

ia      (global input) integer
a's global row index, which points to the beginning of th

PCLAEVSWP()

iz      (global input) integer
z's global row index, which points to the beginning of th

PCLAMR1D()

ia      (global input) integer
a's global row index, which points to the beginning o

PCLAPV2()

ip      (global input) integer
ipiv's global row index, which points to the beginning of th

PCPBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PCPBTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PCPTTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PCPTTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PCSTEIN()

iz      (global input) integer
z's global row index, which points to the beginning of th

PDDBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PDDBTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PDDTTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PDDTTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PDGBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PDLAED0()

iq      (global input) integer
q's global row index, which points to the beginning of th

PDLAED1()

id      (global input) integer
q's global row/col index, which points to the beginning

PDLAEVSWP()

iz      (global input) integer
z's global row index, which points to the beginning of th

PDLAMR1D()

ia      (global input) integer
a's global row index, which points to the beginning o

PDLAPV2()

ip      (global input) integer
ipiv's global row index, which points to the beginning of th

PDPBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PDPBTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PDPTTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PDPTTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PDSTEBZ()

the interval [vl, vu], or the eigenvalues indexed il through iu. a
static partitioning of work is done at the beginning of pdstebz whic
eigenvalues.

PDSTEDC()

iq      (global input) integer
q's global row index, which points to the beginning of th

PDSTEIN()

iz      (global input) integer
z's global row index, which points to the beginning of th

PDSYEV()

ia      (global input) integer
a's global row index, which points to the beginning of th

PDSYEVD()

ia      (global input) integer
a's global row index, which points to the beginning of th

PDSYEVX()

ia      (global input) integer
a's global row index, which points to the beginning of th

PDSYGS2()

ia      (global input) integer
a's global row index, which points to the beginning of th

PDSYGST()

ia      (global input) integer
a's global row index, which points to the beginning of th

PDSYGVX()

insufficient space and pdsygvx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PDSYNGST()

ia      (global input) integer
a's global row index, which points to the beginning of th

PSDBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PSDBTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PSDTTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PSDTTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PSGBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PSLAED0()

iq      (global input) integer
q's global row index, which points to the beginning of th

PSLAED1()

id      (global input) integer
q's global row/col index, which points to the beginning

PSLAEVSWP()

iz      (global input) integer
z's global row index, which points to the beginning of th

PSLAMR1D()

ia      (global input) integer
a's global row index, which points to the beginning o

PSLAPV2()

ip      (global input) integer
ipiv's global row index, which points to the beginning of th

PSPBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PSPBTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PSPTTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PSPTTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PSSTEBZ()

the interval [vl, vu], or the eigenvalues indexed il through iu. a
static partitioning of work is done at the beginning of psstebz whic
eigenvalues.

PSSTEDC()

iq      (global input) integer
q's global row index, which points to the beginning of th

PSSTEIN()

iz      (global input) integer
z's global row index, which points to the beginning of th

PSSYEV()

ia      (global input) integer
a's global row index, which points to the beginning of th

PSSYEVD()

ia      (global input) integer
a's global row index, which points to the beginning of th

PSSYEVX()

ia      (global input) integer
a's global row index, which points to the beginning of th

PSSYGS2()

ia      (global input) integer
a's global row index, which points to the beginning of th

PSSYGST()

ia      (global input) integer
a's global row index, which points to the beginning of th

PSSYGVX()

insufficient space and pssygvx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PSSYNGST()

ia      (global input) integer
a's global row index, which points to the beginning of th

PZDBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PZDBTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PZDTTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PZDTTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PZGBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PZHEEV()

ia      (global input) integer
a's global row index, which points to the beginning of th

PZHEEVD()

ia      (global input) integer
a's global row index, which points to the beginning of th

PZHEEVX()

ia      (global input) integer
a's global row index, which points to the beginning of th

PZHEGS2()

ia      (global input) integer
a's global row index, which points to the beginning of th

PZHEGST()

ia      (global input) integer
a's global row index, which points to the beginning of th

PZHEGVX()

insufficient space and pzhegvx is not able to detect this
before beginning computation.  to get all the eigenvector
space to hold the eigenvectors in z (m .le. descz(n_))

PZHENGST()

ia      (global input) integer
a's global row index, which points to the beginning of th

PZLAEVSWP()

iz      (global input) integer
z's global row index, which points to the beginning of th

PZLAMR1D()

ia      (global input) integer
a's global row index, which points to the beginning o

PZLAPV2()

ip      (global input) integer
ipiv's global row index, which points to the beginning of th

PZPBTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PZPBTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PZPTTRF()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PZPTTRSV()

adjust addressing into matrix space to properly get into
the beginning part of the relevant dat

PZSTEIN()

iz      (global input) integer
z's global row index, which points to the beginning of th

begins

CLAHQR2()

the main loop begins here. i is the loop index and decreases fro
with the active submatrix in rows and columns l to i.

PCLAHQR()

the main loop begins here. i is the loop index and decreases fro
iteration of the loop works  with the active submatrix in rows

PDLAHQR()

the main loop begins here. i is the loop index and decreases fro
iteration of the loop works  with the active submatrix in rows

PSLAHQR()

the main loop begins here. i is the loop index and decreases fro
iteration of the loop works  with the active submatrix in rows

PZLAHQR()

the main loop begins here. i is the loop index and decreases fro
iteration of the loop works  with the active submatrix in rows

ZLAHQR2()

the main loop begins here. i is the loop index and decreases fro
with the active submatrix in rows and columns l to i.

being

CLAHQR2()

to which transformations must be applied. if eigenvalues only are
being computed, i1 and i2 are set inside the main loop

PCDBSV()

value) may vary.
n_a    (global) desca( 3 ) the size of the array dimension being
nb_a   (global) desca( 4 ) the blocking factor used to distribute

PCDBTRS()

value) may vary.
n_a    (global) desca( 3 ) the size of the array dimension being
nb_a   (global) desca( 4 ) the blocking factor used to distribute

PCDTSV()

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

PCDTTRS()

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

PCGBSV()

value) may vary.
n_a    (global) desca( 3 ) the size of the array dimension being
nb_a   (global) desca( 4 ) the blocking factor used to distribute

PCGBTRS()

value) may vary.
n_a    (global) desca( 3 ) the size of the array dimension being
nb_a   (global) desca( 4 ) the blocking factor used to distribute

PCLACONSB()

on entry, the hessenberg matrix whose tridiagonal part is
being scanned

PCLAHQR()

to which transformations must be applied. if eigenvalues only are
being computed, i1 and i2 are set inside the main loop

PCLASMSUB()

on entry, the hessenberg matrix whose tridiagonal part is
being scanned

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()

be made available only within the scope which owns the vector(s)
being operated on.  let x be a generic term for the input vector(s)
an operation involves more than one vector, the processes which re-

PCPBSV()

value) may vary.
n_a    (global) desca( 3 ) the size of the array dimension being
nb_a   (global) desca( 4 ) the blocking factor used to distribute

PCPBTRS()

value) may vary.
n_a    (global) desca( 3 ) the size of the array dimension being
nb_a   (global) desca( 4 ) the blocking factor used to distribute

PCPTSV()

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

PCPTTRS()

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

PDDBSV()

value) may vary.
n_a    (global) desca( 3 ) the size of the array dimension being
nb_a   (global) desca( 4 ) the blocking factor used to distribute

PDDBTRS()

value) may vary.
n_a    (global) desca( 3 ) the size of the array dimension being
nb_a   (global) desca( 4 ) the blocking factor used to distribute

PDDTSV()

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

PDDTTRS()

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

PDGBSV()

value) may vary.
n_a    (global) desca( 3 ) the size of the array dimension being
nb_a   (global) desca( 4 ) the blocking factor used to distribute

PDGBTRS()

value) may vary.
n_a    (global) desca( 3 ) the size of the array dimension being
nb_a   (global) desca( 4 ) the blocking factor used to distribute

PDLACONSB()

on entry, the hessenberg matrix whose tridiagonal part is
being scanned

PDLAED2()

cut which originally split the two submatrices which are now
being recombined
pdlaed3.

PDLAED3()

cut which originally split the two submatrices which are now
being recombined
pdlaed3.

PDLAHQR()

to which transformations must be applied. if eigenvalues only are
being computed, i1 and i2 are set inside the main loop

PDLARED1D()

it contains the same values as bycol, but it is replicated
across all processes rather than being distribute
byall(i) = bycol( numroc(i,desc( nb_ ),myrow,0,nprow ) on the procs

PDLARED2D()

it contains the same values as byrow, but it is replicated
across all processes rather than being distribute
byall(i) = byrow( numroc(i,desc( mb_ ),mycol,0,npcol ) on the procs