Back| U- |
| U_i U_i
factor main partition a_i = l_i {U_i} in each processo
factor main partition a_i = l_i {U_i} in each processo
factor main partition p_i a_i = l_i U_i on each processo lbwl, lbwu: lower and upper bandwidth of local solver factor main partition a_i = l_i {l_i}^c in each processor
or a_i = {U_i}^c {u_i} if e is the upper superdiagona
factor main partition a_i = l_i {U_i} in each processo
factor main partition a_i = l_i {U_i} in each processo
factor main partition p_i a_i = l_i U_i on each processo lbwl, lbwu: lower and upper bandwidth of local solver factor main partition a_i = l_i {l_i}^t in each processor
or a_i = {U_i}^t {u_i} if e is the upper superdiagona
factor main partition a_i = l_i {U_i} in each processo
factor main partition a_i = l_i {U_i} in each processo
factor main partition p_i a_i = l_i U_i on each processo lbwl, lbwu: lower and upper bandwidth of local solver factor main partition a_i = l_i {l_i}^t in each processor
or a_i = {U_i}^t {u_i} if e is the upper superdiagona
factor main partition a_i = l_i {U_i} in each processo
factor main partition a_i = l_i {U_i} in each processo
factor main partition p_i a_i = l_i U_i on each processo lbwl, lbwu: lower and upper bandwidth of local solver factor main partition a_i = l_i {l_i}^c in each processor
or a_i = {U_i}^c {u_i} if e is the upper superdiagona
|
| u11 u11 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * |
| u12 u12 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * |
| u22 u22 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * |
| u23 u23 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * |
| u33 u33 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * |
| u34 u34 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * |
| u44 u44 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * |
| u45 u45 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * |
| u55 u55 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * |
| u56 u56 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * |
| u66 u66 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a31 a42 a53 a64 * * m31 m42 m53 m64 * * |
| ULP ULP ULP (local input) rea unchanged on exit. ULP (local input) double precisio unchanged on exit. $ tst1 = clanhs( '1', i-l+1, h( l, l ), ldh, work ) if( cabs1( h( k, k-1 ) ).le.max( ULP*tst1, smlnum ) 20 continue h22 = smalla(2,2,ki) if ( abs(h10) .le. max(ULP*(abs(h11)+abs(h22)) smalla(2,1,ki) = zero $ tst1 = dlanhs( '1', i-l+1, h( l, l ), ldh, work ) if( abs( h( k, k-1 ) ).le.max( ULP*tst1, smlnum ) 20 continue determined to lie in an interval whose width is abstol or less. if abstol is less than or equal to zero, then ULP*|t eigenvalues will be computed most accurately when abstol is h22 = smalla(2,2,ki) if ( abs(h10) .le. max(ULP*(abs(h11)+abs(h22)) smalla(2,1,ki) = zero $ tst1 = slanhs( '1', i-l+1, h( l, l ), ldh, work ) if( abs( h( k, k-1 ) ).le.max( ULP*tst1, smlnum ) 20 continue determined to lie in an interval whose width is abstol or less. if abstol is less than or equal to zero, then ULP*|t eigenvalues will be computed most accurately when abstol is $ tst1 = zlanhs( '1', i-l+1, h( l, l ), ldh, work ) if( cabs1( h( k, k-1 ) ).le.max( ULP*tst1, smlnum ) 20 continue ULP (local input) rea unchanged on exit. ULP (local input) double precisio unchanged on exit. |
| unblocked unblocked this is the unblocked version of the algorithm, calling level 2 blas arguments use unblocked cod this is the unblocked version of the algorithm, calling level 2 blas arguments use unblocked cod the matrix a does not hold the same values that it would in an unblocked code nor the values that it would hold i this is the unblocked form of the algorithm, calling level 2 blas on should be strictly local to one process. this is the unblocked form of the algorithm, calling level 2 blas on should be strictly local to one process. the matrix a does not hold the same values that it would in an unblocked code nor the values that it would hold i this is the unblocked form of the algorithm, calling level 2 blas on should be strictly local to one process. the matrix a does not hold the same values that it would in an unblocked code nor the values that it would hold i the matrix a does not hold the same values that it would in an unblocked code nor the values that it would hold i this is the unblocked form of the algorithm, calling level 2 blas on should be strictly local to one process. this is the unblocked version of the algorithm, calling level 2 blas arguments use unblocked cod this is the unblocked version of the algorithm, calling level 2 blas arguments use unblocked cod |
| Unchanged Unchanged lds (local input) integer on entry, the leading dimension of s. Unchanged on exit otherwise: apply reflectors to the columns of the matrix Unchanged on exit a (global input/output) complex array, (lda,*) Unchanged on exit n - integer. lds (local input) integer on entry, the leading dimension of s. Unchanged on exit otherwise: apply reflectors to the columns of the matrix Unchanged on exit a (global input/output) double precision array, (lda,*) on entry, the leading dimension of the local array s. Unchanged on exit j (local input) integer Unchanged on exit n - integer. the first nb rows and columns of the matrix are overwritten; the rest of the distributed matrix sub( a ) is Unchanged columns, with the array tauq, represent the unitary where a' is the conjugate transpose of a, and pclacon must be re-called with all the other parameters Unchanged ix (global input) integer being scanned. Unchanged on exit desca (global and local input) integer array of dimension dlen_. m >= 0. Unchanged on exi i (global input) integer reflectors. the other columns of a(ia:ia+n-1,ja:ja+n-k) are Unchanged. see further details ia (global input) integer being scanned. Unchanged on exit desca (global and local input) integer array of dimension dlen_. where d denotes a diagonal element of the reduced matrix, a denotes an element of the original matrix that is Unchanged, and vi denote on entry, this is where the transform starts (row m.) Unchanged on exit a (global input) complex array, dimension on exit, if log10(large) is sufficiently large, the square root of small, otherwise Unchanged large (local input/local output) double precision the first nb rows and columns of the matrix are overwritten; the rest of the distributed matrix sub( a ) is Unchanged columns, with the array tauq, represent the orthogonal pdlacon must be re-called with all the other parameters Unchanged ix (global input) integer being scanned. Unchanged on exit desca (global and local input) integer array of dimension dlen_. m >= 0. Unchanged on exi i (global input) integer reflectors. the other columns of a(ia:ia+n-1,ja:ja+n-k) are Unchanged. see further details ia (global input) integer being scanned. Unchanged on exit desca (global and local input) integer array of dimension dlen_. where d denotes a diagonal element of the reduced matrix, a denotes an element of the original matrix that is Unchanged, and vi denote on entry, this is where the transform starts (row m.) Unchanged on exit a (global input) double precision array, dimension on exit, if log10(large) is sufficiently large, the square root of small, otherwise Unchanged large (local input/local output) real the first nb rows and columns of the matrix are overwritten; the rest of the distributed matrix sub( a ) is Unchanged columns, with the array tauq, represent the orthogonal pslacon must be re-called with all the other parameters Unchanged ix (global input) integer being scanned. Unchanged on exit desca (global and local input) integer array of dimension dlen_. m >= 0. Unchanged on exi i (global input) integer reflectors. the other columns of a(ia:ia+n-1,ja:ja+n-k) are Unchanged. see further details ia (global input) integer being scanned. Unchanged on exit desca (global and local input) integer array of dimension dlen_. where d denotes a diagonal element of the reduced matrix, a denotes an element of the original matrix that is Unchanged, and vi denote on entry, this is where the transform starts (row m.) Unchanged on exit a (global input) real array, dimension the first nb rows and columns of the matrix are overwritten; the rest of the distributed matrix sub( a ) is Unchanged columns, with the array tauq, represent the unitary where a' is the conjugate transpose of a, and pzlacon must be re-called with all the other parameters Unchanged ix (global input) integer being scanned. Unchanged on exit desca (global and local input) integer array of dimension dlen_. m >= 0. Unchanged on exi i (global input) integer reflectors. the other columns of a(ia:ia+n-1,ja:ja+n-k) are Unchanged. see further details ia (global input) integer being scanned. Unchanged on exit desca (global and local input) integer array of dimension dlen_. where d denotes a diagonal element of the reduced matrix, a denotes an element of the original matrix that is Unchanged, and vi denote on entry, this is where the transform starts (row m.) Unchanged on exit a (global input) complex*16 array, dimension lds (local input) integer on entry, the leading dimension of s. Unchanged on exit otherwise: apply reflectors to the columns of the matrix Unchanged on exit a (global input/output) real array, (lda,*) on entry, the leading dimension of the local array s. Unchanged on exit j (local input) integer Unchanged on exit n - integer. lds (local input) integer on entry, the leading dimension of s. Unchanged on exit otherwise: apply reflectors to the columns of the matrix Unchanged on exit a (global input/output) complex*16 array, (lda,*) Unchanged on exit n - integer. |
| unconverged unconverged on output, intvl contains the converged intervals, 1 thru' kf-1, and the unconverged intervals, kf thru' kl-1 intvlct (input/output) integer array, dimension (2*(kl-kf)) on output, intvl contains the converged intervals, 1 thru' kf-1, and the unconverged intervals, kf thru' kl-1 intvlct (input/output) integer array, dimension (2*(kl-kf)) |
| Undefined Undefined on entry, the local row element of a. Undefined on output on entry, the local row element of a. Undefined on output on entry, the local row element of a. Undefined on output on entry, the local row element of a. Undefined on output |
| underdetermined underdetermined pcgels solves overdetermined or underdetermined complex linea or its conjugate-transpose, using a qr or lq factorization of pdgels solves overdetermined or underdetermined real linea or its transpose, using a qr or lq factorization of sub( a ). it is psgels solves overdetermined or underdetermined real linea or its transpose, using a qr or lq factorization of sub( a ). it is pzgels solves overdetermined or underdetermined complex linea or its conjugate-transpose, using a qr or lq factorization of |
| underflow underflow determine the unit roundoff and over/underflow thresholds absolute value of largest distributed matrix element. if amax is very close to overflow or very close to underflow eigenvalues will be computed most accurately when abstol is
set to twice the underflow threshold 2*pslamch('s') not zero
(mod(info/8,2).ne.0)), indicating that some eigenvalues or
eigenvalues will be computed most accurately when abstol is
set to twice the underflow threshold 2*pslamch('s') not zero
(mod(info/8,2).ne.0)), indicating that some eigenvalues or
denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. this is done without over/underflow as long as the final resul sub( a ) may be full, upper triangular, lower triangular or upper absolute value of largest matrix element. if amax is very close to overflow or very close to underflow, the matri sub( x ) by the real scalar 1/a. this is done without overflow or underflow as long as the final sub( x )/a does not overflow o eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to psstebz ) absolute value of largest distributed matrix element. if amax is very close to overflow or very close to underflow pdlabad takes as input the values computed by pdlamch for underflow the log of large is sufficiently large. this subroutine is intended matrix must be scaled so that its largest entry is no greater than overflow**(1/2) * underflow**(1/4) in absolute value than that. rnd = 1.0 when rounding occurs in addition, 0.0 otherwise emin = minimum exponent before (gradual) underflow emax = largest exponent before overflow matrix must be scaled so that its largest entry is no greater than overflow**(1/2) * underflow**(1/4) in absolute value than that. denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. this is done without over/underflow as long as the final resul sub( a ) may be full, upper triangular, lower triangular or upper absolute value of largest matrix element. if amax is very close to overflow or very close to underflow, the matri pdrscl multiplies an n-element real distributed vector sub( x ) by the real scalar 1/a. this is done without overflow or underflow a eigenvalues will be computed most accurately when abstol is
set to the underflow threshold dlamch('u'), not zero
( pdstein ), abstol should be set to 2*pdlamch('s').
eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to pdstebz ) eigenvalues will be computed most accurately when abstol is
set to twice the underflow threshold 2*pdlamch('s') not zero
(mod(info/8,2).ne.0)), indicating that some eigenvalues or
eigenvalues will be computed most accurately when abstol is
set to twice the underflow threshold 2*pdlamch('s') not zero
(mod(info/8,2).ne.0)), indicating that some eigenvalues or
absolute value of largest distributed matrix element. if amax is very close to overflow or very close to underflow pslabad takes as input the values computed by pslamch for underflow the log of large is sufficiently large. this subroutine is intended matrix must be scaled so that its largest entry is no greater than overflow**(1/2) * underflow**(1/4) in absolute value than that. rnd = 1.0 when rounding occurs in addition, 0.0 otherwise emin = minimum exponent before (gradual) underflow emax = largest exponent before overflow matrix must be scaled so that its largest entry is no greater than overflow**(1/2) * underflow**(1/4) in absolute value than that. denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. this is done without over/underflow as long as the final resul sub( a ) may be full, upper triangular, lower triangular or upper absolute value of largest matrix element. if amax is very close to overflow or very close to underflow, the matri psrscl multiplies an n-element real distributed vector sub( x ) by the real scalar 1/a. this is done without overflow or underflow a eigenvalues will be computed most accurately when abstol is
set to the underflow threshold slamch('u'), not zero
( psstein ), abstol should be set to 2*pslamch('s').
eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to psstebz ) eigenvalues will be computed most accurately when abstol is
set to twice the underflow threshold 2*pslamch('s') not zero
(mod(info/8,2).ne.0)), indicating that some eigenvalues or
eigenvalues will be computed most accurately when abstol is
set to twice the underflow threshold 2*pslamch('s') not zero
(mod(info/8,2).ne.0)), indicating that some eigenvalues or
sub( x ) by the real scalar 1/a. this is done without overflow or underflow as long as the final sub( x )/a does not overflow o absolute value of largest distributed matrix element. if amax is very close to overflow or very close to underflow eigenvalues will be computed most accurately when abstol is
set to twice the underflow threshold 2*pdlamch('s') not zero
(mod(info/8,2).ne.0)), indicating that some eigenvalues or
eigenvalues will be computed most accurately when abstol is
set to twice the underflow threshold 2*pdlamch('s') not zero
(mod(info/8,2).ne.0)), indicating that some eigenvalues or
denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. this is done without over/underflow as long as the final resul sub( a ) may be full, upper triangular, lower triangular or upper absolute value of largest matrix element. if amax is very close to overflow or very close to underflow, the matri eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to pdstebz ) determine the unit roundoff and over/underflow thresholds |
| undetermined undetermined 3. if trans = 'c' and m >= n: find the minimum norm solution of an undetermined system sub( a )**h * x = sub( b ) 4. if trans = 'c' and m < n: find the least squares solution of 3. if trans = 't' and m >= n: find the minimum norm solution of an undetermined system sub( a )**t * x = sub( b ) 4. if trans = 't' and m < n: find the least squares solution of 3. if trans = 't' and m >= n: find the minimum norm solution of an undetermined system sub( a )**t * x = sub( b ) 4. if trans = 't' and m < n: find the least squares solution of 3. if trans = 'c' and m >= n: find the minimum norm solution of an undetermined system sub( a )**h * x = sub( b ) 4. if trans = 'c' and m < n: find the least squares solution of |
| undistributed undistributed type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. type_a = 501: lld_a >= size of undistributed dimension, 1 reserved desca( 7 ) reserved for future use. |
| union union an operation involves more than one vector, the processes which re- ceive the result will be the union of the following calculation fo an operation involves more than one vector, the processes which re- ceive the result will be the union of the following calculation fo an operation involves more than one vector, the processes which re- ceive the result will be the union of the following calculation fo an operation involves more than one vector, the processes which re- ceive the result will be the union of the following calculation fo |
| unit unit a = l * u where l is a product of unit lower bidiagona diagonal and first superdiagonal. e (input) complex array, dimension (n-1) the (n-1) off-diagonal elements of the unit bidiagona (see uplo). a = l * u where l is a product of unit lower bidiagona diagonal and first superdiagonal. e (input) complex array, dimension (n-1) the (n-1) off-diagonal elements of the unit bidiagona (see uplo). determine the unit roundoff and over/underflow thresholds from the factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u; the unit diagonal elements of l are not stored ia (global input) integer the elements below the diagonal, with the array tau, repre- sent the unitary matrix q as a product of elementar used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu- tation matrix, l is unit lower triangular, and u is upper triangular used to solve the system of equations sub( a ) * x = sub( b ). a = p * l * u, where p is a permutation matrix, l is a unit lower triangula the factorization has the form sub( a ) = p * l * u, where p is a permutation matrix, l is lower triangular with unit diagona (upper trapezoidal if m < n). the factorization has the form sub( a ) = p * l * u, where p is a permutation matrix, l is lower triangular with unit diagonal ele (upper trapezoidal if m < n). l and u are stored in sub( a ). on entry, this array contains the local pieces of the factors l and u from the factorization sub( a ) = p*l*u; the unit if the elements of sub( x ) are all zero and x(iax,jax) is real, then tau = 0 and h is taken to be the unit matrix otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1. a is non-unit triangular compute grow = 1/g(j) and xbnd = 1/m(j). diag (global input) character = 'n': a(ia:ia+n-1,ja:ja+n-1) is non-unit triangular diag (global input) character*1 = 'n': sub( a ) is non-unit triangular diag (global input) character*1 = 'n': sub( a ) is non-unit triangula specifies whether or not the distributed matrix sub( a ) is unit triangular = 'u': unit triangular. diag (global input) character = 'n': sub( a ) is non-unit triangular where q is a complex unitary distributed matrix of order nq, wit product of ihi-ilo elementary reflectors, as returned by pcgehrd: from the factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u; the unit diagonal elements of l are not stored ia (global input) integer jpvt(j) = i then the jth column of p is the ith canonical unit vector ===================================================================== used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu- tation matrix, l is unit lower triangular, and u is upper triangular used to solve the system of equations sub( a ) * x = sub( b ). a = p * l * u, where p is a permutation matrix, l is a unit lower triangula the factorization has the form sub( a ) = p * l * u, where p is a permutation matrix, l is lower triangular with unit diagona (upper trapezoidal if m < n). the factorization has the form sub( a ) = p * l * u, where p is a permutation matrix, l is lower triangular with unit diagonal ele (upper trapezoidal if m < n). l and u are stored in sub( a ). on entry, this array contains the local pieces of the factors l and u from the factorization sub( a ) = p*l*u; the unit if the elements of sub( x ) are all zero, then tau = 0 and h is taken to be the unit matrix otherwise 1 <= tau <= 2. ilo and ihi must have the same values as in the previous call of pdgehrd. q is equal to the unit matrix except in th if side = 'l', 1 <= ilo <= ihi <= max(1,m); diag (global input) character = 'n': a(ia:ia+n-1,ja:ja+n-1) is non-unit triangular diag (global input) character*1 = 'n': sub( a ) is non-unit triangular diag (global input) character*1 = 'n': sub( a ) is non-unit triangula specifies whether or not the distributed matrix sub( a ) is unit triangular = 'u': unit triangular. diag (global input) character = 'n': sub( a ) is non-unit triangular from the factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u; the unit diagonal elements of l are not stored ia (global input) integer jpvt(j) = i then the jth column of p is the ith canonical unit vector ===================================================================== used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu- tation matrix, l is unit lower triangular, and u is upper triangular used to solve the system of equations sub( a ) * x = sub( b ). a = p * l * u, where p is a permutation matrix, l is a unit lower triangula the factorization has the form sub( a ) = p * l * u, where p is a permutation matrix, l is lower triangular with unit diagona (upper trapezoidal if m < n). the factorization has the form sub( a ) = p * l * u, where p is a permutation matrix, l is lower triangular with unit diagonal ele (upper trapezoidal if m < n). l and u are stored in sub( a ). on entry, this array contains the local pieces of the factors l and u from the factorization sub( a ) = p*l*u; the unit if the elements of sub( x ) are all zero, then tau = 0 and h is taken to be the unit matrix otherwise 1 <= tau <= 2. ilo and ihi must have the same values as in the previous call of psgehrd. q is equal to the unit matrix except in th if side = 'l', 1 <= ilo <= ihi <= max(1,m); diag (global input) character = 'n': a(ia:ia+n-1,ja:ja+n-1) is non-unit triangular diag (global input) character*1 = 'n': sub( a ) is non-unit triangular diag (global input) character*1 = 'n': sub( a ) is non-unit triangula specifies whether or not the distributed matrix sub( a ) is unit triangular = 'u': unit triangular. diag (global input) character = 'n': sub( a ) is non-unit triangular from the factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u; the unit diagonal elements of l are not stored ia (global input) integer the elements below the diagonal, with the array tau, repre- sent the unitary matrix q as a product of elementar used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu- tation matrix, l is unit lower triangular, and u is upper triangular used to solve the system of equations sub( a ) * x = sub( b ). a = p * l * u, where p is a permutation matrix, l is a unit lower triangula the factorization has the form sub( a ) = p * l * u, where p is a permutation matrix, l is lower triangular with unit diagona (upper trapezoidal if m < n). the factorization has the form sub( a ) = p * l * u, where p is a permutation matrix, l is lower triangular with unit diagonal ele (upper trapezoidal if m < n). l and u are stored in sub( a ). on entry, this array contains the local pieces of the factors l and u from the factorization sub( a ) = p*l*u; the unit if the elements of sub( x ) are all zero and x(iax,jax) is real, then tau = 0 and h is taken to be the unit matrix otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1. a is non-unit triangular compute grow = 1/g(j) and xbnd = 1/m(j). diag (global input) character = 'n': a(ia:ia+n-1,ja:ja+n-1) is non-unit triangular diag (global input) character*1 = 'n': sub( a ) is non-unit triangular diag (global input) character*1 = 'n': sub( a ) is non-unit triangula specifies whether or not the distributed matrix sub( a ) is unit triangular = 'u': unit triangular. diag (global input) character = 'n': sub( a ) is non-unit triangular where q is a complex unitary distributed matrix of order nq, wit product of ihi-ilo elementary reflectors, as returned by pzgehrd: a = l * u where l is a product of unit lower bidiagona diagonal and first superdiagonal. e (input) complex array, dimension (n-1) the (n-1) off-diagonal elements of the unit bidiagona (see uplo). determine the unit roundoff and over/underflow thresholds a = l * u where l is a product of unit lower bidiagona diagonal and first superdiagonal. e (input) complex array, dimension (n-1) the (n-1) off-diagonal elements of the unit bidiagona (see uplo). |
| unitary unitary sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagonal form b by an unitary transformation: q' * sub( a ) * p = b if m >= n, b is upper bidiagonal; if m < n, b is lower bidiagonal. sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagonal form b by an unitary transformation: q' * sub( a ) * p = b if m >= n, b is upper bidiagonal; if m < n, b is lower bidiagonal. pcgehd2 reduces a complex general distributed matrix sub( a ) to upper hessenberg form h by an unitary similarity transformation sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). pcgehrd reduces a complex general distributed matrix sub( a ) to upper hessenberg form h by an unitary similarity transformation sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). the elements above the diagonal, with the array tau, repre- sent the unitary matrix q as a product of elementar the elements above the diagonal, with the array tau, repre- sent the unitary matrix q as a product of elementar trapezoidal matrix l; the remaining elements, with the array tau, represent the unitary matrix q as a product o trapezoidal matrix l; the remaining elements, with the array tau, represent the unitary matrix q as a product o the elements below the diagonal, with the array tau, repre- sent the unitary matrix q as a product of elementar the elements below the diagonal, with the array tau, represent the unitary matrix q as a product of elementar the elements below the diagonal, with the array tau, represent the unitary matrix q as a product of elementar trapezoidal matrix r; the remaining elements, with the array tau, represent the unitary matrix q as a product o trapezoidal matrix r; the remaining elements, with the array tau, represent the unitary matrix q as a product o where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix pchentrd reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation pchetd2 reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation pchetrd reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation pchettrd reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagonal form by an unitary transformation q' * a * p, an mation to the unreduced part of sub( a ). elements below the k-th subdiagonal are zero. the reduction is performed by an unitary similarity transformation q' * a * q. th reflector i - v*t*v', and also the matrix y = a * v * t. distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) to complex tridiagonal form by an unitary similarity transformatio needed to apply the transformation to the unreduced part of sub( a ). matrix sub( a ) = [a(ia:ia+m-1,ja:ja+m-1) a(ia:ia+m-1,ja+n-l:ja+n-1)] to upper triangular form by means of unitary transformations the upper trapezoidal matrix sub( a ) is factored as matrices x and/or y of right or left eigenvectors of t, or the products q*x and/or q*y, where q is an input unitary original matrix a = q*t*q', then q*x and q*y are the matrices of sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper triangular form by means of unitary transformations the upper trapezoidal matrix sub( a ) is factored as where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th here q and p**h are the unitary distributed matrices determined b bidiagonal form: a(ia:*,ja:*) = q * b * p**h. q and p**h are defined where q is a complex unitary distributed matrix of order nq, wit product of ihi-ilo elementary reflectors, as returned by pcgehrd: where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix of order nq, wit product of nq-1 elementary reflectors, as returned by pchetrd: this array contains the scalar factors of the elementary reflectors which represent the orthogonal unitary matrix z details). this array contains the scalar factors of the elementary reflectors which represent the orthogonal unitary matrix q details). pdsyttrd reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation this array contains the scalar factors of the elementary reflectors which represent the orthogonal unitary matrix z details). this array contains the scalar factors of the elementary reflectors which represent the orthogonal unitary matrix q details). pssyttrd reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagonal form b by an unitary transformation: q' * sub( a ) * p = b if m >= n, b is upper bidiagonal; if m < n, b is lower bidiagonal. sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagonal form b by an unitary transformation: q' * sub( a ) * p = b if m >= n, b is upper bidiagonal; if m < n, b is lower bidiagonal. pzgehd2 reduces a complex general distributed matrix sub( a ) to upper hessenberg form h by an unitary similarity transformation sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). pzgehrd reduces a complex general distributed matrix sub( a ) to upper hessenberg form h by an unitary similarity transformation sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). the elements above the diagonal, with the array tau, repre- sent the unitary matrix q as a product of elementar the elements above the diagonal, with the array tau, repre- sent the unitary matrix q as a product of elementar trapezoidal matrix l; the remaining elements, with the array tau, represent the unitary matrix q as a product o trapezoidal matrix l; the remaining elements, with the array tau, represent the unitary matrix q as a product o the elements below the diagonal, with the array tau, repre- sent the unitary matrix q as a product of elementar the elements below the diagonal, with the array tau, represent the unitary matrix q as a product of elementar the elements below the diagonal, with the array tau, represent the unitary matrix q as a product of elementar trapezoidal matrix r; the remaining elements, with the array tau, represent the unitary matrix q as a product o trapezoidal matrix r; the remaining elements, with the array tau, represent the unitary matrix q as a product o where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix pzhentrd reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation pzhetd2 reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation pzhetrd reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation pzhettrd reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagonal form by an unitary transformation q' * a * p, an mation to the unreduced part of sub( a ). elements below the k-th subdiagonal are zero. the reduction is performed by an unitary similarity transformation q' * a * q. th reflector i - v*t*v', and also the matrix y = a * v * t. distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) to complex tridiagonal form by an unitary similarity transformatio needed to apply the transformation to the unreduced part of sub( a ). matrix sub( a ) = [a(ia:ia+m-1,ja:ja+m-1) a(ia:ia+m-1,ja+n-l:ja+n-1)] to upper triangular form by means of unitary transformations the upper trapezoidal matrix sub( a ) is factored as matrices x and/or y of right or left eigenvectors of t, or the products q*x and/or q*y, where q is an input unitary original matrix a = q*t*q', then q*x and q*y are the matrices of sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper triangular form by means of unitary transformations the upper trapezoidal matrix sub( a ) is factored as where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th here q and p**h are the unitary distributed matrices determined b bidiagonal form: a(ia:*,ja:*) = q * b * p**h. q and p**h are defined where q is a complex unitary distributed matrix of order nq, wit product of ihi-ilo elementary reflectors, as returned by pzgehrd: where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix of order nq, wit product of nq-1 elementary reflectors, as returned by pzhetrd: |
| unity unity may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). the value of sumsq is assumed to be at least unity and the value o may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). the value of sumsq is assumed to be at least unity and the value o may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: may also be used, since a one-dimensional array is a special case of a two-dimensional array with one dimension of size unity proper orientation: |
| University University code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. implemented for scalapack by: andrew j. cleary, livermore national lab and University of tenn. based on code written by : peter arbenz, eth zurich, 1996. contributed by francoise tisseur, University of manchester reference: f. tisseur and j. dongarra, "a parallel divide and the serial version clacon has been contributed by nick higham, University of manchester. it was originally named sonest, date code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee code developer: andrew j. cleary, University of tennessee this version released: august, 2001. implemented for scalapack by: andrew j. cleary, livermore national lab and University of tenn. based on code written by : peter arbenz, eth zurich, 1996. the serial version dlacon has been contributed by nick higham, University of manchester. it was originally named sonest, date code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee matrix", report cs41, computer science dept., stanford University, july 21, 1966 arguments contributed by francoise tisseur, University of manchester reference: f. tisseur and j. dongarra, "a parallel divide and contributed by francoise tisseur, University of manchester reference: f. tisseur and j. dongarra, "a parallel divide and code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee code developer: andrew j. cleary, University of tennessee this version released: august, 2001. implemented for scalapack by: andrew j. cleary, livermore national lab and University of tenn. based on code written by : peter arbenz, eth zurich, 1996. the serial version slacon has been contributed by nick higham, University of manchester. it was originally named sonest, date code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee matrix", report cs41, computer science dept., stanford University, july 21, 1966 arguments contributed by francoise tisseur, University of manchester reference: f. tisseur and j. dongarra, "a parallel divide and contributed by francoise tisseur, University of manchester reference: f. tisseur and j. dongarra, "a parallel divide and code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. implemented for scalapack by: andrew j. cleary, livermore national lab and University of tenn. based on code written by : peter arbenz, eth zurich, 1996. contributed by francoise tisseur, University of manchester reference: f. tisseur and j. dongarra, "a parallel divide and the serial version zlacon has been contributed by nick higham, University of manchester. it was originally named sonest, date code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. code developer: andrew j. cleary, University of tennessee this version released: august, 2001. |
| unknowns unknowns only the eliminations of unknowns > ln-bw have an effect o only the eliminations of unknowns > ln-bw have an effect o only the eliminations of unknowns > ln-bw have an effect o only the eliminations of unknowns > ln-bw have an effect o |
| unless unless if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the user supplie before beginning computation. to get all the eigenvectors if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the user supplie before beginning computation. to get all the eigenvectors if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the user supplie before beginning computation. to get all the eigenvectors if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the user supplie before beginning computation. to get all the eigenvectors if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the user supplie before beginning computation. to get all the eigenvectors if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the user supplie before beginning computation. to get all the eigenvectors if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the user supplie before beginning computation. to get all the eigenvectors if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the user supplie before beginning computation. to get all the eigenvectors |
| unnecessary unnecessary ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ===================================================================== ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ===================================================================== ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication ja = ib alignment restriction that prevents unnecessary communication |
| unreasonable unreasonable this is a scalapack internal subroutine and arguments are not checked for unreasonable values arguments this is a scalapack internal procedure and arguments are not checked for unreasonable values arguments this is a scalapack internal procedure and arguments are not checked for unreasonable values arguments this is a scalapack internal subroutine and arguments are not checked for unreasonable values arguments this is a scalapack internal procedure and arguments are not checked for unreasonable values arguments this is a scalapack internal procedure and arguments are not checked for unreasonable values arguments |
| unreduced unreduced (nbulge > 1) and the first shift is starting in the middle of an unreduced hessenberg matrix because of two or more consecutiv (nbulge > 1) and the first shift is starting in the middle of an unreduced hessenberg matrix because of two or more consecutive smal returns the matrices x and y which are needed to apply the transfor- mation to the unreduced part of sub( a ) if m >= n, sub( a ) is reduced to upper bidiagonal form; if m < n, to i (global input) integer the global location of the bottom of the unreduced unchanged on exit. v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an update of the form i (global input) integer the global location of the bottom of the unreduced unchanged on exit. q' * sub( a ) * q, and returns the matrices v and w which are needed to apply the transformation to the unreduced part of sub( a ) if uplo = 'u', pclatrd reduces the last nb rows and columns of a and returns the matrices x and y which are needed to apply the transformation to the unreduced part of sub( a ) if m >= n, sub( a ) is reduced to upper bidiagonal form; if m < n, to i (global input) integer the global location of the bottom of the unreduced unchanged on exit. v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an update of the form i (global input) integer the global location of the bottom of the unreduced unchanged on exit. and returns the matrices v and w which are needed to apply the transformation to the unreduced part of sub( a ) if uplo = 'u', pdlatrd reduces the last nb rows and columns of a and returns the matrices x and y which are needed to apply the transformation to the unreduced part of sub( a ) if m >= n, sub( a ) is reduced to upper bidiagonal form; if m < n, to i (global input) integer the global location of the bottom of the unreduced unchanged on exit. v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an update of the form i (global input) integer the global location of the bottom of the unreduced unchanged on exit. and returns the matrices v and w which are needed to apply the transformation to the unreduced part of sub( a ) if uplo = 'u', pslatrd reduces the last nb rows and columns of a returns the matrices x and y which are needed to apply the transfor- mation to the unreduced part of sub( a ) if m >= n, sub( a ) is reduced to upper bidiagonal form; if m < n, to i (global input) integer the global location of the bottom of the unreduced unchanged on exit. v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an update of the form i (global input) integer the global location of the bottom of the unreduced unchanged on exit. q' * sub( a ) * q, and returns the matrices v and w which are needed to apply the transformation to the unreduced part of sub( a ) if uplo = 'u', pzlatrd reduces the last nb rows and columns of a (nbulge > 1) and the first shift is starting in the middle of an unreduced hessenberg matrix because of two or more consecutive smal (nbulge > 1) and the first shift is starting in the middle of an unreduced hessenberg matrix because of two or more consecutiv |
| unsorted unsorted pclaevswp moves the eigenvectors (potentially unsorted) fro array, sorted so that the corresponding eigenvalues are sorted. pdlaevswp moves the eigenvectors (potentially unsorted) fro array, sorted so that the corresponding eigenvalues are sorted. pslaevswp moves the eigenvectors (potentially unsorted) fro array, sorted so that the corresponding eigenvalues are sorted. pzlaevswp moves the eigenvectors (potentially unsorted) fro array, sorted so that the corresponding eigenvalues are sorted. |
| unsymmetric unsymmetric on entry, this array contains the local pieces of the n-by-n unsymmetric banded distributed cholesky factor l o this local portion is stored in the packed banded format on entry, this array contains the local pieces of the n-by-n unsymmetric banded distributed cholesky factor l o this local portion is stored in the packed banded format on entry, this array contains the local pieces of the n-by-n unsymmetric banded distributed cholesky factor l o this local portion is stored in the packed banded format on entry, this array contains the local pieces of the n-by-n unsymmetric banded distributed cholesky factor l o this local portion is stored in the packed banded format on entry, this array contains the local pieces of the n-by-n unsymmetric banded distributed cholesky factor l o this local portion is stored in the packed banded format on entry, this array contains the local pieces of the n-by-n unsymmetric banded distributed cholesky factor l o this local portion is stored in the packed banded format on entry, this array contains the local pieces of the n-by-n unsymmetric banded distributed cholesky factor l o this local portion is stored in the packed banded format on entry, this array contains the local pieces of the n-by-n unsymmetric banded distributed cholesky factor l o this local portion is stored in the packed banded format |
| until until perform qr iterations on rows and columns ilo to i until subdiagonal element has become negligible. this is the lookahead loop, going until we hav do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation however, if the workspace is insufficient (see lwork), tol may be decreased until all eigenvectors to b no reorthogonalization will be done if orfac equals zero. however, if the workspace is insufficient (see lwork), tol may be decreased until all eigenvectors to b no reorthogonalization will be done if orfac equals zero. perform qr iterations on rows and columns ilo to i until subdiagonal element has become negligible. do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation however, if the workspace is insufficient (see lwork), this tolerance may be decreased until all eigenvectors to b no orthogonalization will be done if orfac equals zero. do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation perform qr iterations on rows and columns ilo to i until subdiagonal element has become negligible. do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation however, if the workspace is insufficient (see lwork), this tolerance may be decreased until all eigenvectors to b no orthogonalization will be done if orfac equals zero. however, if the workspace is insufficient (see lwork), tol may be decreased until all eigenvectors to b no reorthogonalization will be done if orfac equals zero. however, if the workspace is insufficient (see lwork), tol may be decreased until all eigenvectors to b no reorthogonalization will be done if orfac equals zero. do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation perform qr iterations on rows and columns ilo to i until subdiagonal element has become negligible. do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation however, if the workspace is insufficient (see lwork), this tolerance may be decreased until all eigenvectors to b no orthogonalization will be done if orfac equals zero. however, if the workspace is insufficient (see lwork), tol may be decreased until all eigenvectors to b no reorthogonalization will be done if orfac equals zero. however, if the workspace is insufficient (see lwork), tol may be decreased until all eigenvectors to b no reorthogonalization will be done if orfac equals zero. do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation however, if the workspace is insufficient (see lwork), tol may be decreased until all eigenvectors to b no reorthogonalization will be done if orfac equals zero. however, if the workspace is insufficient (see lwork), tol may be decreased until all eigenvectors to b no reorthogonalization will be done if orfac equals zero. perform qr iterations on rows and columns ilo to i until subdiagonal element has become negligible. do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation do until this proc is needed to modify other procs' equation however, if the workspace is insufficient (see lwork), this tolerance may be decreased until all eigenvectors to b no orthogonalization will be done if orfac equals zero. perform qr iterations on rows and columns ilo to i until subdiagonal element has become negligible. this is the lookahead loop, going until we hav |
| untouched untouched truea( index, index:n ) = a( index, index:n ) the rest of a is untouched after the current block column of a is updated, truea( index, index:n ) = a( index, index:n ) the rest of a is untouched after the current block column of a is updated, truea( index, index:n ) = a( index, index:n ) the rest of a is untouched after the current block column of a is updated, truea( index, index:n ) = a( index, index:n ) the rest of a is untouched after the current block column of a is updated, |
| unused unused calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors that they appear in the argument list for name. n1 is used first, n2 second, and so on, and unused problem dimensions ar 3) the parameter value returned by pjlaenv is checked for validity calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors calculate new ja one while dropping off unused processors |
| Update Update Update iteration count
calculate the Update block for previous proc, e_i = gl_i{gu_i
calculate the Update block for previous proc, e_i = gl_i{gu_i
Update the last bw columns of a_i (code modified from cgbtrs only the eliminations of unknowns > ln-bw have an effect on to form q explicitly, use scalapack subroutine pcungqr. to use q to Update another matrix, use scalapack subroutine pcunmqr the matrix z is represented as a product of elementary reflectors to form q explicitly, use scalapack subroutine pcungrq. to use q to Update another matrix, use scalapack subroutine pcunmrq the matrix z is represented as a product of elementary reflectors array ( nq x anb-1 ) for efficiency. since only the lower triangular portion of a is Updated, av is computed as two local triangular matrix-vector multiplications (both in pieces of the distributed m-by-nb matrix x(ix:ix+m-1,jx:jx+nb-1) required to Update the unreduce v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an Update of the form the local pieces of the n-by-nb_w matrix w required to Update the unreduced part of sub( a ) iw (global input) integer compute the Update
calculate the Update block for previous proc, e_i = g_i{g_i}^
calculate the Update block for previous proc, e_i = g_i{g_i}^
calculate the Update block for previous proc, e_i = gl_i{gu_i
calculate the Update block for previous proc, e_i = gl_i{gu_i
Update the last bw columns of a_i (code modified from dgbtrs only the eliminations of unknowns > ln-bw have an effect on to form q explicitly, use scalapack subroutine pdorgqr. to use q to Update another matrix, use scalapack subroutine pdormqr the matrix z is represented as a product of elementary reflectors to form q explicitly, use scalapack subroutine pdorgrq. to use q to Update another matrix, use scalapack subroutine pdormrq the matrix z is represented as a product of elementary reflectors pieces of the distributed m-by-nb matrix x(ix:ix+m-1,jx:jx+nb-1) required to Update the unreduce v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an Update of the form the local pieces of the n-by-nb_w matrix w required to Update the unreduced part of sub( a ) iw (global input) integer
calculate the Update block for previous proc, e_i = g_i{g_i}^
calculate the Update block for previous proc, e_i = g_i{g_i}^
array ( nq x anb-1 ) for efficiency. since only the lower triangular portion of a is Updated, av is computed as two local triangular matrix-vector multiplications (both in
calculate the Update block for previous proc, e_i = gl_i{gu_i
calculate the Update block for previous proc, e_i = gl_i{gu_i
Update the last bw columns of a_i (code modified from dgbtrs only the eliminations of unknowns > ln-bw have an effect on to form q explicitly, use scalapack subroutine psorgqr. to use q to Update another matrix, use scalapack subroutine psormqr the matrix z is represented as a product of elementary reflectors to form q explicitly, use scalapack subroutine psorgrq. to use q to Update another matrix, use scalapack subroutine psormrq the matrix z is represented as a product of elementary reflectors pieces of the distributed m-by-nb matrix x(ix:ix+m-1,jx:jx+nb-1) required to Update the unreduce v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an Update of the form the local pieces of the n-by-nb_w matrix w required to Update the unreduced part of sub( a ) iw (global input) integer
calculate the Update block for previous proc, e_i = g_i{g_i}^
calculate the Update block for previous proc, e_i = g_i{g_i}^
array ( nq x anb-1 ) for efficiency. since only the lower triangular portion of a is Updated, av is computed as two local triangular matrix-vector multiplications (both in
calculate the Update block for previous proc, e_i = gl_i{gu_i
calculate the Update block for previous proc, e_i = gl_i{gu_i
Update the last bw columns of a_i (code modified from zgbtrs only the eliminations of unknowns > ln-bw have an effect on to form q explicitly, use scalapack subroutine pzungqr. to use q to Update another matrix, use scalapack subroutine pzunmqr the matrix z is represented as a product of elementary reflectors to form q explicitly, use scalapack subroutine pzungrq. to use q to Update another matrix, use scalapack subroutine pzunmrq the matrix z is represented as a product of elementary reflectors array ( nq x anb-1 ) for efficiency. since only the lower triangular portion of a is Updated, av is computed as two local triangular matrix-vector multiplications (both in pieces of the distributed m-by-nb matrix x(ix:ix+m-1,jx:jx+nb-1) required to Update the unreduce v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an Update of the form the local pieces of the n-by-nb_w matrix w required to Update the unreduced part of sub( a ) iw (global input) integer compute the Update
calculate the Update block for previous proc, e_i = g_i{g_i}^
calculate the Update block for previous proc, e_i = g_i{g_i}^
Update iteration count |
| updated updated j2 and j3 are computed after ju has been updated factorize the current block of jb columns on entry, the matrix to receive the reflections. the updated matrix on exit lda (local input) integer j2 and j3 are computed after ju has been updated factorize the current block of jb columns on entry, the matrix to receive the reflections. the updated matrix on exit lda (local input) integer array ( nq x anb-1 ) for efficiency. since only the lower triangular portion of a is updated, av is computed as two local triangular matrix-vector multiplications (both in the else part of this if needs updated vcopy, thi dimension ( 2*desct(lld_) ) additional workspace may be required if pclattrs is updated pdlaed1 computes the updated eigensystem of a diagona in parallel. be combined. on exit, d contains the trailing (n-k) updated eigenvalue be combined. on exit, d contains the trailing (n-k) updated eigenvalue array ( nq x anb-1 ) for efficiency. since only the lower triangular portion of a is updated, av is computed as two local triangular matrix-vector multiplications (both in pslaed1 computes the updated eigensystem of a diagona in parallel. be combined. on exit, d contains the trailing (n-k) updated eigenvalue be combined. on exit, d contains the trailing (n-k) updated eigenvalue array ( nq x anb-1 ) for efficiency. since only the lower triangular portion of a is updated, av is computed as two local triangular matrix-vector multiplications (both in array ( nq x anb-1 ) for efficiency. since only the lower triangular portion of a is updated, av is computed as two local triangular matrix-vector multiplications (both in the else part of this if needs updated vcopy, thi dimension ( 2*desct(lld_) ) additional workspace may be required if pzlattrs is updated j2 and j3 are computed after ju has been updated factorize the current block of jb columns on entry, the matrix to receive the reflections. the updated matrix on exit lda (local input) integer j2 and j3 are computed after ju has been updated factorize the current block of jb columns on entry, the matrix to receive the reflections. the updated matrix on exit lda (local input) integer |
| updates updates pchengst performs the same function as pchegst, but is based on rank 2k updates, which are faster and more scalable tha pdsyngst performs the same function as pdhegst, but is based on rank 2k updates, which are faster and more scalable tha pssyngst performs the same function as pshegst, but is based on rank 2k updates, which are faster and more scalable tha pzhengst performs the same function as pzhegst, but is based on rank 2k updates, which are faster and more scalable tha |
| updating updating we keep the block column of a up-to-date to minimize the work required in updating the current column of a. updatin updating the current column of a is not (only the current z (global input) double precision array, dimension (n) on entry, z contains the updating vector (the las the second sub-eigenvector matrix). z (global input) double precision array, dimension (n) on entry, z contains the updating vector (the las the second sub-eigenvector matrix). we keep the block column of a up-to-date to minimize the work required in updating the current column of a. updatin updating the current column of a is not (only the current z (global input) real array, dimension (n) on entry, z contains the updating vector (the las the second sub-eigenvector matrix). z (global input) real array, dimension (n) on entry, z contains the updating vector (the las the second sub-eigenvector matrix). we keep the block column of a up-to-date to minimize the work required in updating the current column of a. updatin updating the current column of a is not (only the current we keep the block column of a up-to-date to minimize the work required in updating the current column of a. updatin updating the current column of a is not (only the current |
| UPLO UPLO UPLO (input) character* UPLO (input) character* of the tridiagonal matrix a is stored and the form of the UPLO - character*1 lower triangular matrix as follows: UPLO (input) character* factor u or l from the factorization computed by dpttrf (see UPLO) b (input/output) complex array, dimension (ldb,nrhs) UPLO - character*1 lower triangular matrix as follows: ************************************************************** case UPLO = 'u' UPLO (global input) character* symmetric matrix a is stored: UPLO (global input) character* symmetric matrix a is stored: UPLO (global input) character* hermitian matrix a is stored: UPLO (global input) characte factored as u**h*u; UPLO (global input) characte factored as u**h*u; UPLO (global input) character* = 'l': lower triangles of sub( a ) and sub( b ) are stored. pchengst calls pchegst when UPLO='u', hence pchengst provide support for UPLO='u' is limited to calling the old, slow, pchetr UPLO (global input) characte hermitian matrix sub( a ) is stored: UPLO (global input) characte hermitian matrix sub( a ) is stored: UPLO (global input) characte hermitian matrix sub( a ) is stored: UPLO (global input) characte copied: UPLO (global input) characte copied: UPLO = 'u' uplo = 'l |\ | | |\ | UPLO = 'u' uplo = 'l |\ | | |\ | UPLO (global input) characte symmetric distributed matrix sub( a ) is to be referenced: UPLO (global input) characte set: UPLO (global input) characte set: if UPLO = 'u', pclatrd reduces the last nb rows and columns of if uplo = 'l', pclatrd reduces the first nb rows and columns of a if UPLO = 'u' or 'u' then the upper triangle of the result is stored if uplo = 'l' or 'l' then the lower triangle of the result is stored, if UPLO = 'u' or 'u' then the upper triangle of the result is stored if uplo = 'l' or 'l' then the lower triangle of the result is stored, UPLO (global input) characte = 'l': lower triangle of a(1:n, ja:ja+n-1) is stored. matrix with bandwidth bw. depending on the value of UPLO, a stores either u or l in the equ UPLO (global input) characte a(ia:ia+n-1,ja:ja+n-1) is upper or lower triangular. UPLO (global input) character* hermitian matrix sub( a ) is stored. sub( a ) = u**h * u, if UPLO = 'u', o sub( a ) = l * l**h, if uplo = 'l', factor the matrix a (after equilibration if fact = 'e') as a = u**t* u, if UPLO = 'u', o where u is an upper triangular matrix and l is a lower triangular sub( a ) = u' * u , if UPLO = 'u', o sub( a ) = l * l', if uplo = 'l', sub( a ) = u' * u , if UPLO = 'u', o sub( a ) = l * l', if uplo = 'l', UPLO (global input) character* = 'l': lower triangle of sub( a ) is stored. UPLO (global input) characte = 'l': lower triangle of sub( a ) is stored. UPLO (global input) characte = 'l': lower triangle of a(1:n, ja:ja+n-1) is stored. matrix. depending on the value of UPLO, a stores either u or l in the equ ************************************************************** case UPLO = 'u' UPLO (global input) characte = 'l': a(ia:ia+n-1,ja:ja+n-1) is lower triangular. UPLO (global input) character* = 'l': sub( a ) is lower triangular. UPLO (global input) character* = 'l': sub( a ) is lower triangular. UPLO (global input) characte or lower triangular: UPLO (global input) characte = 'l': sub( a ) is lower triangular. if UPLO = 'u', q = h(nq-1) . . . h(2) h(1) if uplo = 'l', q = h(1) h(2) . . . h(nq-1). ************************************************************** case UPLO = 'u' UPLO (global input) characte copied: UPLO (global input) characte copied: UPLO = 'u' uplo = 'l |\ | | |\ | UPLO (global input) characte symmetric distributed matrix sub( a ) is to be referenced: UPLO (global input) characte set: UPLO (global input) characte set: if UPLO = 'u', pdlatrd reduces the last nb rows and columns of if uplo = 'l', pdlatrd reduces the first nb rows and columns of a if UPLO = 'u' or 'u' then the upper triangle of the result is stored if uplo = 'l' or 'l' then the lower triangle of the result is stored, if UPLO = 'u' or 'u' then the upper triangle of the result is stored if uplo = 'l' or 'l' then the lower triangle of the result is stored, if UPLO = 'u', q = h(nq-1) . . . h(2) h(1) if uplo = 'l', q = h(1) h(2) . . . h(nq-1). UPLO (global input) characte = 'l': lower triangle of a(1:n, ja:ja+n-1) is stored. matrix with bandwidth bw. depending on the value of UPLO, a stores either u or l in the equ UPLO (global input) characte a(ia:ia+n-1,ja:ja+n-1) is upper or lower triangular. UPLO (global input) character* symmetric matrix sub( a ) is stored. sub( a ) = u**t * u, if UPLO = 'u', o sub( a ) = l * l**t, if uplo = 'l', factor the matrix a (after equilibration if fact = 'e') as a = u**t* u, if UPLO = 'u', o where u is an upper triangular matrix and l is a lower triangular sub( a ) = u' * u , if UPLO = 'u', o sub( a ) = l * l', if uplo = 'l', sub( a ) = u' * u , if UPLO = 'u', o sub( a ) = l * l', if uplo = 'l', UPLO (global input) character* = 'l': lower triangle of sub( a ) is stored. UPLO (global input) characte = 'l': lower triangle of sub( a ) is stored. end of "if( lsame( UPLO, 'l' ) )".. UPLO (global input) character* symmetric matrix a is stored: UPLO (global input) character* symmetric matrix a is stored: UPLO (global input) character* symmetric matrix a is stored: UPLO (global input) characte factored as u**t*u; UPLO (global input) characte factored as u**t*u; UPLO (global input) character* = 'l': lower triangles of sub( a ) and sub( b ) are stored. pdsyngst calls pdhegst when UPLO='u', hence pdhengst provide support for UPLO='u' is limited to calling the old, slow, pdsytr UPLO (global input) characte symmetric matrix sub( a ) is stored: UPLO (global input) characte symmetric matrix sub( a ) is stored: UPLO (global input) characte hermitian matrix sub( a ) is stored: UPLO (global input) characte = 'l': a(ia:ia+n-1,ja:ja+n-1) is lower triangular. UPLO (global input) character* = 'l': sub( a ) is lower triangular. UPLO (global input) character* = 'l': sub( a ) is lower triangular. UPLO (global input) characte or lower triangular: UPLO (global input) characte = 'l': sub( a ) is lower triangular. the character options to the subroutine name, concatenated into a single character string. for example, UPLO = 'u' be specified as opts = 'utn'. ************************************************************** case UPLO = 'u' UPLO (global input) characte copied: UPLO (global input) characte copied: UPLO = 'u' uplo = 'l |\ | | |\ | UPLO (global input) characte symmetric distributed matrix sub( a ) is to be referenced: UPLO (global input) characte set: UPLO (global input) characte set: if UPLO = 'u', pslatrd reduces the last nb rows and columns of if uplo = 'l', pslatrd reduces the first nb rows and columns of a if UPLO = 'u' or 'u' then the upper triangle of the result is stored if uplo = 'l' or 'l' then the lower triangle of the result is stored, if UPLO = 'u' or 'u' then the upper triangle of the result is stored if uplo = 'l' or 'l' then the lower triangle of the result is stored, if UPLO = 'u', q = h(nq-1) . . . h(2) h(1) if uplo = 'l', q = h(1) h(2) . . . h(nq-1). UPLO (global input) characte = 'l': lower triangle of a(1:n, ja:ja+n-1) is stored. matrix with bandwidth bw. depending on the value of UPLO, a stores either u or l in the equ UPLO (global input) characte a(ia:ia+n-1,ja:ja+n-1) is upper or lower triangular. UPLO (global input) character* symmetric matrix sub( a ) is stored. sub( a ) = u**t * u, if UPLO = 'u', o sub( a ) = l * l**t, if uplo = 'l', factor the matrix a (after equilibration if fact = 'e') as a = u**t* u, if UPLO = 'u', o where u is an upper triangular matrix and l is a lower triangular sub( a ) = u' * u , if UPLO = 'u', o sub( a ) = l * l', if uplo = 'l', sub( a ) = u' * u , if UPLO = 'u', o sub( a ) = l * l', if uplo = 'l', UPLO (global input) character* = 'l': lower triangle of sub( a ) is stored. UPLO (global input) characte = 'l': lower triangle of sub( a ) is stored. end of "if( lsame( UPLO, 'l' ) )".. UPLO (global input) character* symmetric matrix a is stored: UPLO (global input) character* symmetric matrix a is stored: UPLO (global input) character* symmetric matrix a is stored: UPLO (global input) characte factored as u**t*u; UPLO (global input) characte factored as u**t*u; UPLO (global input) character* = 'l': lower triangles of sub( a ) and sub( b ) are stored. pssyngst calls pshegst when UPLO='u', hence pshengst provide support for UPLO='u' is limited to calling the old, slow, pssytr UPLO (global input) characte symmetric matrix sub( a ) is stored: UPLO (global input) characte symmetric matrix sub( a ) is stored: UPLO (global input) characte hermitian matrix sub( a ) is stored: UPLO (global input) characte = 'l': a(ia:ia+n-1,ja:ja+n-1) is lower triangular. UPLO (global input) character* = 'l': sub( a ) is lower triangular. UPLO (global input) character* = 'l': sub( a ) is lower triangular. UPLO (global input) characte or lower triangular: UPLO (global input) characte = 'l': sub( a ) is lower triangular. ************************************************************** case UPLO = 'u' UPLO (global input) character* symmetric matrix a is stored: UPLO (global input) character* symmetric matrix a is stored: UPLO (global input) character* hermitian matrix a is stored: UPLO (global input) characte factored as u**h*u; UPLO (global input) characte factored as u**h*u; UPLO (global input) character* = 'l': lower triangles of sub( a ) and sub( b ) are stored. pzhengst calls pzhegst when UPLO='u', hence pzhengst provide support for UPLO='u' is limited to calling the old, slow, pzhetr UPLO (global input) characte hermitian matrix sub( a ) is stored: UPLO (global input) characte hermitian matrix sub( a ) is stored: UPLO (global input) characte hermitian matrix sub( a ) is stored: UPLO (global input) characte copied: UPLO (global input) characte copied: UPLO = 'u' uplo = 'l |\ | | |\ | UPLO = 'u' uplo = 'l |\ | | |\ | UPLO (global input) characte symmetric distributed matrix sub( a ) is to be referenced: UPLO (global input) characte set: UPLO (global input) characte set: if UPLO = 'u', pzlatrd reduces the last nb rows and columns of if uplo = 'l', pzlatrd reduces the first nb rows and columns of a if UPLO = 'u' or 'u' then the upper triangle of the result is stored if uplo = 'l' or 'l' then the lower triangle of the result is stored, if UPLO = 'u' or 'u' then the upper triangle of the result is stored if uplo = 'l' or 'l' then the lower triangle of the result is stored, UPLO (global input) characte = 'l': lower triangle of a(1:n, ja:ja+n-1) is stored. matrix with bandwidth bw. depending on the value of UPLO, a stores either u or l in the equ UPLO (global input) characte a(ia:ia+n-1,ja:ja+n-1) is upper or lower triangular. UPLO (global input) character* hermitian matrix sub( a ) is stored. sub( a ) = u**h * u, if UPLO = 'u', o sub( a ) = l * l**h, if uplo = 'l', factor the matrix a (after equilibration if fact = 'e') as a = u**t* u, if UPLO = 'u', o where u is an upper triangular matrix and l is a lower triangular sub( a ) = u' * u , if UPLO = 'u', o sub( a ) = l * l', if uplo = 'l', sub( a ) = u' * u , if UPLO = 'u', o sub( a ) = l * l', if uplo = 'l', UPLO (global input) character* = 'l': lower triangle of sub( a ) is stored. UPLO (global input) characte = 'l': lower triangle of sub( a ) is stored. UPLO (global input) characte = 'l': lower triangle of a(1:n, ja:ja+n-1) is stored. matrix. depending on the value of UPLO, a stores either u or l in the equ ************************************************************** case UPLO = 'u' UPLO (global input) characte = 'l': a(ia:ia+n-1,ja:ja+n-1) is lower triangular. UPLO (global input) character* = 'l': sub( a ) is lower triangular. UPLO (global input) character* = 'l': sub( a ) is lower triangular. UPLO (global input) characte or lower triangular: UPLO (global input) characte = 'l': sub( a ) is lower triangular. if UPLO = 'u', q = h(nq-1) . . . h(2) h(1) if uplo = 'l', q = h(1) h(2) . . . h(nq-1). UPLO (input) character* factor u or l from the factorization computed by spttrf (see UPLO) b (input/output) complex array, dimension (ldb,nrhs) UPLO - character*1 lower triangular matrix as follows: UPLO (input) character* UPLO (input) character* of the tridiagonal matrix a is stored and the form of the UPLO - character*1 lower triangular matrix as follows: |
| upon upon where: lwork, as defined previously, depends upon the numbe nsytrd_lwopt = n + 2*( anb+1 )*( 4*nps+2 ) + where: lwork, as defined previously, depends upon the numbe nsytrd_lwopt = n + 2*( anb+1 )*( 4*nps+2 ) + where: lwork, as defined previously, depends upon the numbe nsytrd_lwopt = n + 2*( anb+1 )*( 4*nps+2 ) + where: lwork, as defined previously, depends upon the numbe nsytrd_lwopt = n + 2*( anb+1 )*( 4*nps+2 ) + |
| upper upper on exit, details of the factorization: u is stored as an upper triangular band matrix with kl+ku superdiagonals i factorization are stored in rows kl+ku+2 to 2*kl+ku+1. where l is a product of unit lower bidiagonal matrices and u is upper triangular with nonzeros in only the mai d (input) complex array, dimension (n) the n diagonal elements of the upper triangular matrix u fro where x is an n element vector and t is an n by n upper or lower triangular matrix arguments on exit, details of the factorization: u is stored as an upper triangular band matrix with kl+ku superdiagonals i factorization are stored in rows kl+ku+2 to 2*kl+ku+1. where l is a product of unit lower bidiagonal matrices and u is upper triangular with nonzeros in only the mai d (input) complex array, dimension (n) the n diagonal elements of the upper triangular matrix u fro where x is an n element vector and t is an n by n upper or lower triangular matrix arguments locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a offset to workspace for upper triangular facto locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a offset to workspace for upper triangular facto du (local input/local output) complex pointer to local part of global vector storing the upper diagonal of th aligned with d. offset to workspace for upper triangular facto du (local input/local output) complex pointer to local part of global vector storing the upper diagonal of th aligned with d. offset to workspace for upper triangular facto locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a lbwl, lbwu: lower and upper bandwidth of local solve lm is the number of rows which is usually nb except for locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pcgebd2 reduces a complex general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagona pcgebrd reduces a complex general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagona locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pcgehd2 reduces a complex general distributed matrix sub( a ) to upper hessenberg form h by an unitary similarity transformation sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). pcgehrd reduces a complex general distributed matrix sub( a ) to upper hessenberg form h by an unitary similarity transformation sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu- tation matrix, l is unit lower triangular, and u is upper triangular used to solve the system of equations sub( a ) * x = sub( b ). locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a permutation matrix, l is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and u is upper triangula permutation matrix, l is lower triangular with unit diagonal ele- ments (lower trapezoidal if m > n), and u is upper triangula locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where r11 is upper triangular, an if n <= p, t = ( 0 t12 ) n, or if n > p, t = ( t11 ) n-p, where r12 or r21 is upper triangular, an if p >= n, t = ( t11 ) n , or if p < n, t = ( t11 t12 ) p, uplo (global input) character*1 specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character*1 specifies whether the upper or lower triangular part of th = 'u': upper triangular locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locq( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pclabrd reduces the first nb rows and columns of a complex general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper returns the matrices x and y which are needed to apply the transfor- locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a t (local output) complex array, dimension (nb_a,nb_a) the upper triangular matrix t y (local output) complex pointer into the local memory locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a upper triangular matri locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. cto * a(i,j) / cfrom does not over/underflow. type specifies that sub( a ) may be full, upper triangular, lower triangular or uppe locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if uplo = 'u', pclatrd reduces the last nb rows and columns of a matrix, of which the upper triangle is supplied matrix, of which the lower triangle is supplied. pclatrz reduces the m-by-n ( m<=n ) complex upper trapezoida to upper triangular form by means of unitary transformations. a is upper triangular pclauu2 computes the product u * u' or l' * l, where the triangular factor u or l is stored in the upper or lower triangular part o pclauum computes the product u * u' or l' * l, where the triangular factor u or l is stored in the upper or lower triangular part o locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored modify upper off_diagonal block with diagonal bloc uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where u is an upper triangular matrix and l is a lower triangula system of equations. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where u is an upper triangular matrix and l is lower triangular notes where u is an upper triangular matrix and l is lower triangular notes locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored factor main partition a_i = l_i {l_i}^c in each processor
or a_i = {u_i}^c {u_i} if e is the upper superdiagona
uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pctrevc computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix t in parallel the right eigenvector x and the left eigenvector y of t corresponding locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pctrti2 computes the inverse of a complex upper or lower triangula contained in one and only one process memory space (local operation). pctrtri computes the inverse of a upper or lower triangula locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pctzrzf reduces the m-by-n ( m<=n ) complex upper trapezoidal matri of unitary transformations. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a offset to workspace for upper triangular facto locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a offset to workspace for upper triangular facto du (local input/local output) double precision pointer to local part of global vector storing the upper diagonal of th aligned with d. offset to workspace for upper triangular facto du (local input/local output) double precision pointer to local part of global vector storing the upper diagonal of th aligned with d. offset to workspace for upper triangular facto locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a lbwl, lbwu: lower and upper bandwidth of local solve lm is the number of rows which is usually nb except for locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pdgebd2 reduces a real general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagona pdgebrd reduces a real general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagona locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pdgehd2 reduces a real general distributed matrix sub( a ) to upper hessenberg form h by an orthogonal similarity transforma sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). pdgehrd reduces a real general distributed matrix sub( a ) to upper hessenberg form h by an orthogonal similarity transforma sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu- tation matrix, l is unit lower triangular, and u is upper triangular used to solve the system of equations sub( a ) * x = sub( b ). locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a permutation matrix, l is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and u is upper triangula permutation matrix, l is lower triangular with unit diagonal ele- ments (lower trapezoidal if m > n), and u is upper triangula locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where r11 is upper triangular, an if n <= p, t = ( 0 t12 ) n, or if n > p, t = ( t11 ) n-p, where r12 or r21 is upper triangular, an if p >= n, t = ( t11 ) n , or if p < n, t = ( t11 t12 ) p, of the values computed by pdlamch. this subroutine is needed because pdlamch does not compensate for poor arithmetic in the upper half o pdlabrd reduces the first nb rows and columns of a real general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper and returns the matrices x and y which are needed to apply the locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a following types a column in the q2 matrix is: 1 : non-zero in the upper half only 3 : non-zero in the lower half only; locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a t (local output) double precision array, dimension (nb_a,nb_a) the upper triangular matrix t y (local output) double precision pointer into the local memory locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a upper triangular matri locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. cto * a(i,j) / cfrom does not over/underflow. type specifies that sub( a ) may be full, upper triangular, lower triangular or uppe locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if uplo = 'u', pdlatrd reduces the last nb rows and columns of a matrix, of which the upper triangle is supplied matrix, of which the lower triangle is supplied. pdlatrz reduces the m-by-n ( m<=n ) real upper trapezoidal matri upper triangular form by means of orthogonal transformations. pdlauu2 computes the product u * u' or l' * l, where the triangular factor u or l is stored in the upper or lower triangular part o pdlauum computes the product u * u' or l' * l, where the triangular factor u or l is stored in the upper or lower triangular part o locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored modify upper off_diagonal block with diagonal bloc uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where u is an upper triangular matrix and l is a lower triangula system of equations. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where u is an upper triangular matrix and l is lower triangular notes where u is an upper triangular matrix and l is lower triangular notes locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a e (local input/local output) double precision pointer to local part of global vector storing the upper diagonal of th aligned with d. factor main partition a_i = l_i {l_i}^t in each processor
or a_i = {u_i}^t {u_i} if e is the upper superdiagona
e (local input/local output) double precision pointer to local part of global vector storing the upper diagonal of th aligned with d. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a vu (global input) double precision if range='v', the upper bound of the interval to be searche returned. vu must be greater than vl. not referenced if locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a uplo (global input) character*1 specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character*1 specifies whether the upper or lower triangular part of th = 'u': upper triangular locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locq( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pdtrti2 computes the inverse of a real upper or lower triangula contained in one and only one process memory space (local operation). pdtrtri computes the inverse of a upper or lower triangula locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pdtzrzf reduces the m-by-n ( m<=n ) real upper trapezoidal matri of orthogonal transformations. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a this routine will not function correctly if it is converted to all lower case. converting it to all upper case is allowed arguments locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a offset to workspace for upper triangular facto locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a offset to workspace for upper triangular facto du (local input/local output) real pointer to local part of global vector storing the upper diagonal of th aligned with d. offset to workspace for upper triangular facto du (local input/local output) real pointer to local part of global vector storing the upper diagonal of th aligned with d. offset to workspace for upper triangular facto locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a lbwl, lbwu: lower and upper bandwidth of local solve lm is the number of rows which is usually nb except for locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a psgebd2 reduces a real general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagona psgebrd reduces a real general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagona locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a psgehd2 reduces a real general distributed matrix sub( a ) to upper hessenberg form h by an orthogonal similarity transforma sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). psgehrd reduces a real general distributed matrix sub( a ) to upper hessenberg form h by an orthogonal similarity transforma sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu- tation matrix, l is unit lower triangular, and u is upper triangular used to solve the system of equations sub( a ) * x = sub( b ). locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a permutation matrix, l is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and u is upper triangula permutation matrix, l is lower triangular with unit diagonal ele- ments (lower trapezoidal if m > n), and u is upper triangula locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where r11 is upper triangular, an if n <= p, t = ( 0 t12 ) n, or if n > p, t = ( t11 ) n-p, where r12 or r21 is upper triangular, an if p >= n, t = ( t11 ) n , or if p < n, t = ( t11 t12 ) p, of the values computed by pslamch. this subroutine is needed because pslamch does not compensate for poor arithmetic in the upper half o pslabrd reduces the first nb rows and columns of a real general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper and returns the matrices x and y which are needed to apply the locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a following types a column in the q2 matrix is: 1 : non-zero in the upper half only 3 : non-zero in the lower half only; locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a t (local output) real array, dimension (nb_a,nb_a) the upper triangular matrix t y (local output) real pointer into the local memory locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a upper triangular matri locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. cto * a(i,j) / cfrom does not over/underflow. type specifies that sub( a ) may be full, upper triangular, lower triangular or uppe locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if uplo = 'u', pslatrd reduces the last nb rows and columns of a matrix, of which the upper triangle is supplied matrix, of which the lower triangle is supplied. pslatrz reduces the m-by-n ( m<=n ) real upper trapezoidal matri upper triangular form by means of orthogonal transformations. pslauu2 computes the product u * u' or l' * l, where the triangular factor u or l is stored in the upper or lower triangular part o pslauum computes the product u * u' or l' * l, where the triangular factor u or l is stored in the upper or lower triangular part o locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored modify upper off_diagonal block with diagonal bloc uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where u is an upper triangular matrix and l is a lower triangula system of equations. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where u is an upper triangular matrix and l is lower triangular notes where u is an upper triangular matrix and l is lower triangular notes locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a e (local input/local output) real pointer to local part of global vector storing the upper diagonal of th aligned with d. factor main partition a_i = l_i {l_i}^t in each processor
or a_i = {u_i}^t {u_i} if e is the upper superdiagona
e (local input/local output) real pointer to local part of global vector storing the upper diagonal of th aligned with d. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a vu (global input) real if range='v', the upper bound of the interval to be searche returned. vu must be greater than vl. not referenced if locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a uplo (global input) character*1 specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character*1 specifies whether the upper or lower triangular part of th = 'u': upper triangular locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locq( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pstrti2 computes the inverse of a real upper or lower triangula contained in one and only one process memory space (local operation). pstrtri computes the inverse of a upper or lower triangula locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pstzrzf reduces the m-by-n ( m<=n ) real upper trapezoidal matri of orthogonal transformations. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a offset to workspace for upper triangular facto locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a offset to workspace for upper triangular facto locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a du (local input/local output) complex*16 pointer to local part of global vector storing the upper diagonal of th aligned with d. offset to workspace for upper triangular facto du (local input/local output) complex*16 pointer to local part of global vector storing the upper diagonal of th aligned with d. offset to workspace for upper triangular facto locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a lbwl, lbwu: lower and upper bandwidth of local solve lm is the number of rows which is usually nb except for locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pzgebd2 reduces a complex general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagona pzgebrd reduces a complex general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper or lower bidiagona locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pzgehd2 reduces a complex general distributed matrix sub( a ) to upper hessenberg form h by an unitary similarity transformation sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). pzgehrd reduces a complex general distributed matrix sub( a ) to upper hessenberg form h by an unitary similarity transformation sub( a ) = a(ia+n-1:ia+n-1,ja+n-1:ja+n-1). locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu- tation matrix, l is unit lower triangular, and u is upper triangular used to solve the system of equations sub( a ) * x = sub( b ). locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a permutation matrix, l is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and u is upper triangula permutation matrix, l is lower triangular with unit diagonal ele- ments (lower trapezoidal if m > n), and u is upper triangula locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where r11 is upper triangular, an if n <= p, t = ( 0 t12 ) n, or if n > p, t = ( t11 ) n-p, where r12 or r21 is upper triangular, an if p >= n, t = ( t11 ) n , or if p < n, t = ( t11 t12 ) p, uplo (global input) character*1 specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character*1 specifies whether the upper or lower triangular part of th = 'u': upper triangular locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locq( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pzlabrd reduces the first nb rows and columns of a complex general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper returns the matrices x and y which are needed to apply the transfor- locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a t (local output) complex*16 array, dimension (nb_a,nb_a) the upper triangular matrix t y (local output) complex*16 pointer into the local memory locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a upper triangular matri locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. cto * a(i,j) / cfrom does not over/underflow. type specifies that sub( a ) may be full, upper triangular, lower triangular or uppe locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a if uplo = 'u', pzlatrd reduces the last nb rows and columns of a matrix, of which the upper triangle is supplied matrix, of which the lower triangle is supplied. pzlatrz reduces the m-by-n ( m<=n ) complex upper trapezoida to upper triangular form by means of unitary transformations. a is upper triangular pzlauu2 computes the product u * u' or l' * l, where the triangular factor u or l is stored in the upper or lower triangular part o pzlauum computes the product u * u' or l' * l, where the triangular factor u or l is stored in the upper or lower triangular part o locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored modify upper off_diagonal block with diagonal bloc uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where u is an upper triangular matrix and l is a lower triangula system of equations. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a where u is an upper triangular matrix and l is lower triangular notes where u is an upper triangular matrix and l is lower triangular notes locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored factor main partition a_i = l_i {l_i}^c in each processor
or a_i = {u_i}^c {u_i} if e is the upper superdiagona
uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pztrevc computes some or all of the right and/or left eigenvectors of a complex upper triangular matrix t in parallel the right eigenvector x and the left eigenvector y of t corresponding locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pztrti2 computes the inverse of a complex upper or lower triangula contained in one and only one process memory space (local operation). pztrtri computes the inverse of a upper or lower triangula locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a pztzrzf reduces the m-by-n ( m<=n ) complex upper trapezoidal matri of unitary transformations. locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). an upper bound for these quantities may be computed by locc( n ) <= ceil( ceil(n/nb_a)/npcol )*nb_a on exit, details of the factorization: u is stored as an upper triangular band matrix with kl+ku superdiagonals i factorization are stored in rows kl+ku+2 to 2*kl+ku+1. where l is a product of unit lower bidiagonal matrices and u is upper triangular with nonzeros in only the mai d (input) complex array, dimension (n) the n diagonal elements of the upper triangular matrix u fro where x is an n element vector and t is an n by n upper or lower triangular matrix arguments on exit, details of the factorization: u is stored as an upper triangular band matrix with kl+ku superdiagonals i factorization are stored in rows kl+ku+2 to 2*kl+ku+1. where l is a product of unit lower bidiagonal matrices and u is upper triangular with nonzeros in only the mai d (input) complex array, dimension (n) the n diagonal elements of the upper triangular matrix u fro where x is an n element vector and t is an n by n upper or lower triangular matrix arguments |
| USCAL USCAL otherwise, scale column of a by USCAL before do otherwise, scale column of a by USCAL before do |
| use use use unblocked cod perform qr iterations on rows and columns ilo to i until a submatrix of order 1 or 2 splits off at the bottom because if remaining matrix is 2-by-2, use slae2 or slaev use unblocked cod if remaining matrix is 2-by-2, use dlae2 or slaev gaussian elimination without pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex get values out of descriptor for use in code gaussian elimination without pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex get values out of descriptor for use in code gaussian elimination with pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex r(i) and c(j) are restricted to be between smlnum = smallest safe number and bignum = largest safe number. use of these scalin sub( a ) but works well in practice. array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute pchentrd is a prototype version of pchetrd which uses tailore when the workspace provided by the user is adequate. array a. mb_a (global) desca( mb_ ) the blocking factor used t nb_a (global) desca( nb_ ) the blocking factor used to array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute perform qr iterations on rows and columns ilo to i until a submatrix of order 1 or 2 splits off at the bottom because also note that this routine will only work for k1-k2 being in the same mb (or nb) block. if you want to pivot a full matrix, use compute a bound on the computed solution vector to see if the level 2 pblas routine pctrsv can be used array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute cholesky factorization is used to factor a reordering o get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex get values out of descriptor for use in code cholesky factorization is used to factor a reordering o get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex get values out of descriptor for use in code array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute gaussian elimination without pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real get values out of descriptor for use in code gaussian elimination without pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real get values out of descriptor for use in code gaussian elimination with pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real r(i) and c(j) are restricted to be between smlnum = smallest safe number and bignum = largest safe number. use of these scalin sub( a ) but works well in practice. array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute perform qr iterations on rows and columns ilo to i until a submatrix of order 1 or 2 splits off at the bottom because also note that this routine will only work for k1-k2 being in the same mb (or nb) block. if you want to pivot a full matrix, use cholesky factorization is used to factor a reordering o get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real get values out of descriptor for use in code cholesky factorization is used to factor a reordering o get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real get values out of descriptor for use in code pdsyntrd is a prototype version of pdsytrd which uses tailore when the workspace provided by the user is adequate. array a. mb_a (global) desca( mb_ ) the blocking factor used t nb_a (global) desca( nb_ ) the blocking factor used to based on pdzasum from the level 1 pblas. the change is to use the 'genuine' absolute value the serial version of this routine was originally contributed by but not optimal, performance on many of the currently available computers. users are encouraged to modify this subroutine to se and problem size information in the arguments. based on pscasum from the level 1 pblas. the change is to use the 'genuine' absolute value the serial version of this routine was originally contributed by gaussian elimination without pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real get values out of descriptor for use in code gaussian elimination without pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real get values out of descriptor for use in code gaussian elimination with pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real r(i) and c(j) are restricted to be between smlnum = smallest safe number and bignum = largest safe number. use of these scalin sub( a ) but works well in practice. array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute perform qr iterations on rows and columns ilo to i until a submatrix of order 1 or 2 splits off at the bottom because also note that this routine will only work for k1-k2 being in the same mb (or nb) block. if you want to pivot a full matrix, use cholesky factorization is used to factor a reordering o get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real get values out of descriptor for use in code cholesky factorization is used to factor a reordering o get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real get values out of descriptor for use in code pssyntrd is a prototype version of pssytrd which uses tailore when the workspace provided by the user is adequate. array a. mb_a (global) desca( mb_ ) the blocking factor used t nb_a (global) desca( nb_ ) the blocking factor used to gaussian elimination without pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex get values out of descriptor for use in code gaussian elimination without pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex get values out of descriptor for use in code gaussian elimination with pivoting is used to factor a reorderin get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex r(i) and c(j) are restricted to be between smlnum = smallest safe number and bignum = largest safe number. use of these scalin sub( a ) but works well in practice. array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute pzhentrd is a prototype version of pzhetrd which uses tailore when the workspace provided by the user is adequate. array a. mb_a (global) desca( mb_ ) the blocking factor used t nb_a (global) desca( nb_ ) the blocking factor used to array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute perform qr iterations on rows and columns ilo to i until a submatrix of order 1 or 2 splits off at the bottom because also note that this routine will only work for k1-k2 being in the same mb (or nb) block. if you want to pivot a full matrix, use compute a bound on the computed solution vector to see if the level 2 pblas routine pztrsv can be used array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute cholesky factorization is used to factor a reordering o get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex get values out of descriptor for use in code cholesky factorization is used to factor a reordering o get values out of descriptor for use in code where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex get values out of descriptor for use in code array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute use unblocked cod if remaining matrix is 2-by-2, use slae2 or slaev use unblocked cod perform qr iterations on rows and columns ilo to i until a submatrix of order 1 or 2 splits off at the bottom because if remaining matrix is 2-by-2, use dlae2 or dlaev |
| used used upper triangular band matrix with kl+ku superdiagonals in rows 1 to kl+ku+1, and the multipliers used during th see below for further details. has been completed, but the factor u is exactly singular, and division by zero will occur if it is used specifies the "number" of the first reflector. this is used as an index into vecs if block is set upper triangular band matrix with kl+ku superdiagonals in rows 1 to kl+ku+1, and the multipliers used during th see below for further details. has been completed, but the factor u is exactly singular, and division by zero will occur if it is used specifies the "number" of the first reflector. this is used as an index into vecs if block is set gaussian elimination without pivoting is used to factor a reorderin where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex gaussian elimination without pivoting is used to factor a reorderin where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex gaussian elimination with pivoting is used to factor a reorderin calculate new ja one while dropping off unused processors where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute the lu decomposition with partial pivoting and row interchanges is used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu l and u are stored in sub( a ). the factored form of sub( a ) is then array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute buted matrix a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute on entry, the symmetric matrix a. if uplo = 'u', only the upper triangular part of a is used to define the elements o triangular part of a is used to define the elements of the array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used t nb_a (global) desca( nb_ ) the blocking factor used to array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute pclacon estimates the 1-norm of a square, complex distributed matrix a. reverse communication is used for evaluating matrix-vecto information is implicitly contained within iv, ix, descv, and descx. array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute clahqr used to have a single row application and a singl more clever. we break each transformation down into 3 to 1. indeed, i suspect that ib should always be set to 1 or ignored with 1 used in its place pclamr1d has not been tested except withint the contect of array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums whil irsr0 : pointer to part of work used to store the rowsums after icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums whil irsr0 : pointer to part of work used to store the rowsums after array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute compute a bound on the computed solution vector to see if the level 2 pblas routine pctrsv can be used array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute cholesky factorization is used to factor a reordering o where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute the cholesky decomposition is used to factor sub( a ) a sub( a ) = u**h * u, if uplo = 'u', or array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute cholesky factorization is used to factor a reordering o where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex array a. mb_a (global) desca[ mb_ ] the blocking factor used to distribu nb_a (global) desca[ nb_ ] the blocking factor used to distribu- array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute gaussian elimination without pivoting is used to factor a reorderin where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real gaussian elimination without pivoting is used to factor a reorderin where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real gaussian elimination with pivoting is used to factor a reorderin calculate new ja one while dropping off unused processors where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute the lu decomposition with partial pivoting and row interchanges is used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu l and u are stored in sub( a ). the factored form of sub( a ) is then array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute pdlacon estimates the 1-norm of a square, real distributed matrix a. reverse communication is used for evaluating matrix-vector products is implicitly contained within iv, ix, descv, and descx. array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute rho (input) double precision the subdiagonal entry used to create the rank-1 modification work (local workspace/output) double precision array, nb (global input) integer the blocking factor used to distribute the columns of th nb (global input) integer the blocking factor used to distribute the columns of th array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute dlahqr used to have a single row application and a singl more clever. we break each transformation down into 3 to 1. indeed, i suspect that ib should always be set to 1 or ignored with 1 used in its place pdlamr1d has not been tested except withint the contect of array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums whil irsr0 : pointer to part of work used to store the rowsums after array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute cholesky factorization is used to factor a reordering o where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute the cholesky decomposition is used to factor sub( a ) a sub( a ) = u**t * u, if uplo = 'u', or array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute cholesky factorization is used to factor a reordering o where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real calculate new ja one while dropping off unused processors array a. mb_a (global) desca[ mb_ ] the blocking factor used to distribu nb_a (global) desca[ nb_ ] the blocking factor used to distribu- less. if abstol is less than or equal to zero, then ulp*|t|
will be used, where |t| means the 1-norm of t
set to the underflow threshold dlamch('u'), not zero.
matrix also. on entry, z contains the orthogonal matrix used to reduce the original matrix t array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute buted matrix a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute on entry, the symmetric matrix a. if uplo = 'u', only the upper triangular part of a is used to define the elements o triangular part of a is used to define the elements of the array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used t nb_a (global) desca( nb_ ) the blocking factor used to array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute at present, only n1 is used, and it (n1) is used only fo array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute gaussian elimination without pivoting is used to factor a reorderin where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real gaussian elimination without pivoting is used to factor a reorderin where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real gaussian elimination with pivoting is used to factor a reorderin calculate new ja one while dropping off unused processors where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute the lu decomposition with partial pivoting and row interchanges is used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu l and u are stored in sub( a ). the factored form of sub( a ) is then array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute pslacon estimates the 1-norm of a square, real distributed matrix a. reverse communication is used for evaluating matrix-vector products is implicitly contained within iv, ix, descv, and descx. array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute rho (input) real the subdiagonal entry used to create the rank-1 modification work (local workspace/output) real array, nb (global input) integer the blocking factor used to distribute the columns of th nb (global input) integer the blocking factor used to distribute the columns of th array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute slahqr used to have a single row application and a singl more clever. we break each transformation down into 3 to 1. indeed, i suspect that ib should always be set to 1 or ignored with 1 used in its place pslamr1d has not been tested except withint the contect of array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums whil irsr0 : pointer to part of work used to store the rowsums after array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute cholesky factorization is used to factor a reordering o where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute the cholesky decomposition is used to factor sub( a ) a sub( a ) = u**t * u, if uplo = 'u', or array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute cholesky factorization is used to factor a reordering o where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real calculate new ja one while dropping off unused processors array a. mb_a (global) desca[ mb_ ] the blocking factor used to distribu nb_a (global) desca[ nb_ ] the blocking factor used to distribu- less. if abstol is less than or equal to zero, then ulp*|t|
will be used, where |t| means the 1-norm of t
set to the underflow threshold slamch('u'), not zero.
matrix also. on entry, z contains the orthogonal matrix used to reduce the original matrix t array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute buted matrix a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute on entry, the symmetric matrix a. if uplo = 'u', only the upper triangular part of a is used to define the elements o triangular part of a is used to define the elements of the array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used t nb_a (global) desca( nb_ ) the blocking factor used to array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute gaussian elimination without pivoting is used to factor a reorderin where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex array a. mb_a (global) desca[ mb_ ] the blocking factor used to distribu nb_a (global) desca[ nb_ ] the blocking factor used to distribu- gaussian elimination without pivoting is used to factor a reorderin where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex gaussian elimination with pivoting is used to factor a reorderin calculate new ja one while dropping off unused processors where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute the lu decomposition with partial pivoting and row interchanges is used to factor sub( a ) as sub( a ) = p * l * u, where p is a permu l and u are stored in sub( a ). the factored form of sub( a ) is then array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute buted matrix a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute on entry, the symmetric matrix a. if uplo = 'u', only the upper triangular part of a is used to define the elements o triangular part of a is used to define the elements of the array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used t nb_a (global) desca( nb_ ) the blocking factor used to array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute pzlacon estimates the 1-norm of a square, complex distributed matrix a. reverse communication is used for evaluating matrix-vecto information is implicitly contained within iv, ix, descv, and descx. array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute zlahqr used to have a single row application and a singl more clever. we break each transformation down into 3 to 1. indeed, i suspect that ib should always be set to 1 or ignored with 1 used in its place pzlamr1d has not been tested except withint the contect of array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums whil irsr0 : pointer to part of work used to store the rowsums after icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums whil irsr0 : pointer to part of work used to store the rowsums after array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute compute a bound on the computed solution vector to see if the level 2 pblas routine pztrsv can be used array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute cholesky factorization is used to factor a reordering o where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute the cholesky decomposition is used to factor sub( a ) a sub( a ) = u**h * u, if uplo = 'u', or array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute cholesky factorization is used to factor a reordering o where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute upper triangular band matrix with kl+ku superdiagonals in rows 1 to kl+ku+1, and the multipliers used during th see below for further details. has been completed, but the factor u is exactly singular, and division by zero will occur if it is used specifies the "number" of the first reflector. this is used as an index into vecs if block is set upper triangular band matrix with kl+ku superdiagonals in rows 1 to kl+ku+1, and the multipliers used during th see below for further details. has been completed, but the factor u is exactly singular, and division by zero will occur if it is used specifies the "number" of the first reflector. this is used as an index into vecs if block is set |
| User User lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz pivot indices for local factorizations. Users *should not* alter the contents betwee User-input value of partition siz pivot indices for local factorizations. Users *should not* alter the contents betwee if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the User supplie before beginning computation. to get all the eigenvectors if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the User supplie before beginning computation. to get all the eigenvectors codes (either the serial, chetrd, or the parallel code, pchettrd) when the workspace provided by the User is adequate lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz in parallel, using inverse iteration. the eigenvectors found correspond to User specified eigenvalues. pcstein does no of orthogonalization is controlled by the input parameter lwork. lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz pivot indices for local factorizations. Users *should not* alter the contents betwee User-input value of partition siz pivot indices for local factorizations. Users *should not* alter the contents betwee lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz pdstebz computes the eigenvalues of a symmetric tridiagonal matrix in parallel. the User may ask for all eigenvalues, all eigenvalues i static partitioning of work is done at the beginning of pdstebz which in parallel, using inverse iteration. the eigenvectors found correspond to User specified eigenvalues. pdstein does no of orthogonalization is controlled by the input parameter lwork. if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the User supplie before beginning computation. to get all the eigenvectors if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the User supplie before beginning computation. to get all the eigenvectors codes (either the serial, dsytrd, or the parallel code, pdsyttrd) when the workspace provided by the User is adequate lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz pivot indices for local factorizations. Users *should not* alter the contents betwee User-input value of partition siz pivot indices for local factorizations. Users *should not* alter the contents betwee lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz psstebz computes the eigenvalues of a symmetric tridiagonal matrix in parallel. the User may ask for all eigenvalues, all eigenvalues i static partitioning of work is done at the beginning of psstebz which in parallel, using inverse iteration. the eigenvectors found correspond to User specified eigenvalues. psstein does no of orthogonalization is controlled by the input parameter lwork. if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the User supplie before beginning computation. to get all the eigenvectors if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the User supplie before beginning computation. to get all the eigenvectors codes (either the serial, ssytrd, or the parallel code, pssyttrd) when the workspace provided by the User is adequate lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz pivot indices for local factorizations. Users *should not* alter the contents betwee User-input value of partition siz pivot indices for local factorizations. Users *should not* alter the contents betwee if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the User supplie before beginning computation. to get all the eigenvectors if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the User supplie before beginning computation. to get all the eigenvectors codes (either the serial, zhetrd, or the parallel code, pzhettrd) when the workspace provided by the User is adequate lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz lwork (local input or global input) integer size of User-input workspace work returned in work(1) and an error code is returned. lwork>= User-input value of partition siz laf (local input) integer size of User-input auxiliary fillin space af. must be > if laf is not large enough, an error code will be returned User-input value of partition siz in parallel, using inverse iteration. the eigenvectors found correspond to User specified eigenvalues. pzstein does no of orthogonalization is controlled by the input parameter lwork. |
| users users pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee pchettrd is not intended to be called directly. all users ar appropriate. a must be in cyclic format (i.e. mb = nb = 1), pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee pdsyttrd is not intended to be called directly. all users ar appropriate. a must be in cyclic format (i.e. mb = nb = 1), but not optimal, performance on many of the currently available computers. users are encouraged to modify this subroutine to se and problem size information in the arguments. pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee pssyttrd is not intended to be called directly. all users ar appropriate. a must be in cyclic format (i.e. mb = nb = 1), pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee pzhettrd is not intended to be called directly. all users ar appropriate. a must be in cyclic format (i.e. mb = nb = 1), |
| uses uses the following method uses more flops than necessary bu pcgesvx uses the lu factorization to compute the solution to pchentrd is a prototype version of pchetrd which uses tailore when the workspace provided by the user is adequate. pchettrd uses five local arrays work ( inh ) dimension ( np, anb+1): array h the following method uses more flops than necessary bu pcposvx uses the cholesky factorization a = u**h*u or a = l*l**h t the following method uses more flops than necessary bu pdgesvx uses the lu factorization to compute the solution to a rea contained in the input intervals [ intvl(2*j-1), intvl(2*j) ] where j = 1,...,minp. it uses and computes the function n(w), which i or equal to its argument w. the following method uses more flops than necessary bu pdposvx uses the cholesky factorization a = u**t*u or a = l*l**t t pdsyntrd is a prototype version of pdsytrd which uses tailore when the workspace provided by the user is adequate. pdsyttrd uses five local arrays work ( inh ) dimension ( np, anb+1): array h the data to the best data layout for each transformation. pxyyttrd.f uses a data layout blocking factor of 1 and ===================================================================== the following method uses more flops than necessary bu psgesvx uses the lu factorization to compute the solution to a rea contained in the input intervals [ intvl(2*j-1), intvl(2*j) ] where j = 1,...,minp. it uses and computes the function n(w), which i or equal to its argument w. the following method uses more flops than necessary bu psposvx uses the cholesky factorization a = u**t*u or a = l*l**t t pssyntrd is a prototype version of pssytrd which uses tailore when the workspace provided by the user is adequate. pssyttrd uses five local arrays work ( inh ) dimension ( np, anb+1): array h the following method uses more flops than necessary bu pzgesvx uses the lu factorization to compute the solution to pzhentrd is a prototype version of pzhetrd which uses tailore when the workspace provided by the user is adequate. pzhettrd uses five local arrays work ( inh ) dimension ( np, anb+1): array h the following method uses more flops than necessary bu pzposvx uses the cholesky factorization a = u**h*u or a = l*l**h t |
| using using cdbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. cdttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form ddbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. ddttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pcdbtrf and this is stored in af. if a linear system is to be solved using pcdbtrs after the factorizatio if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pcdttrf and this is stored in af. if a linear system is to be solved using pcdttrs after the factorizatio if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pcgbtrf and this is stored in af. if a linear system is to be solved using pcgbtrs after the factorizatio distributed complex matrix a(ia:ia+n-1,ja:ja+n-1), in either the 1-norm or the infinity-norm, using the lu factorization computed b systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1), or its conjugate-transpose, using a qr or lq factorization o workspaces required respectively for the subprograms pclange, pslared1d, pslared2d, pcgebrd. using th 4. the system of equations is solved for x using the factored for pcgetf2 computes an lu factorization of a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using pcgetrf computes an lu factorization of a general m-by-n distributed matrix sub( a ) = (ia:ia+m-1,ja:ja+n-1) using partial pivoting wit pcgetri computes the inverse of a distributed matrix using the l computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted with a general n-by-n distributed matrix sub( a ) using the l sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a, a**t or a**h pcheevd computes all the eigenvalues and eigenvectors of a hermitian matrix a by using a divide and conquer algorithm arguments v and the nb-by-n matrix u' which are needed, with x and y, to apply the transformation to the unreduced part of the matrix, using a bloc ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an update of the form pclaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scalin pclaqsy equilibrates a symmetric distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in th which is needed, with w, to apply the transformation to the unreduced part of the matrix, using a hermitian rank-2k update of the form if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pcpbtrf and this is stored in af. if a linear system is to be solved using pcpbtrs after the factorizatio 1-norm) of a complex hermitian positive definite distributed matrix using the cholesky factorization a = u**h*u or a = l*l**h computed b 4. the system of equations is solved for x using the factored for pcpotri computes the inverse of a complex hermitian positive definite distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using th pcpotrf. where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a n-by-n hermitian positive definite distributed matrix using the cholesk sub( b ) denotes the distributed matrix b(ib:ib+n-1,jb:jb+nrhs-1). if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pcpttrf and this is stored in af. if a linear system is to be solved using pcpttrs after the factorizatio pcstein computes the eigenvectors of a symmetric tridiagonal matrix in parallel, using inverse iteration. the eigenvectors foun orthogonalize vectors that are on different processes. the extent = 'b': compute all right and/or left eigenvectors, and backtransform them using the input matrice = 's': compute selected right and/or left eigenvectors, if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pddbtrf and this is stored in af. if a linear system is to be solved using pddbtrs after the factorizatio if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pddttrf and this is stored in af. if a linear system is to be solved using pddttrs after the factorizatio if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pdgbtrf and this is stored in af. if a linear system is to be solved using pdgbtrs after the factorizatio distributed real matrix a(ia:ia+n-1,ja:ja+n-1), in either the 1-norm or the infinity-norm, using the lu factorization computed by pdgetrf an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), and systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1), or its transpose, using a qr or lq factorization of sub( a ). it i workspaces required respectively for the subprograms pdlange, pdlared1d, pdlared2d, pdgebrd. using th 4. the system of equations is solved for x using the factored for pdgetf2 computes an lu factorization of a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using pdgetrf computes an lu factorization of a general m-by-n distributed matrix sub( a ) = (ia:ia+m-1,ja:ja+n-1) using partial pivoting wit pdgetri computes the inverse of a distributed matrix using the l computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted with a general n-by-n distributed matrix sub( a ) using the l sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a or a**t and v and the nb-by-n matrix u' which are needed, with x and y, to apply the transformation to the unreduced part of the matrix, using a bloc ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. pdlaed0 computes all eigenvalues and corresponding eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method the final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. the eigenvectors fo the overall problem. v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an update of the form pdlaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scalin pdlaqsy equilibrates a symmetric distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in th which is needed, with w, to apply the transformation to the unreduced part of the matrix, using a symmetric rank-2k update of the form if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pdpbtrf and this is stored in af. if a linear system is to be solved using pdpbtrs after the factorizatio 1-norm) of a real symmetric positive definite distributed matrix using the cholesky factorization a = u**t*u or a = l*l**t computed b 4. the system of equations is solved for x using the factored for pdpotri computes the inverse of a real symmetric positive definite distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using th pdpotrf. where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a n-by-n symmetric positive definite distributed matrix using the cholesk sub( b ) denotes the distributed matrix b(ib:ib+n-1,jb:jb+nrhs-1). if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pdpttrf and this is stored in af. if a linear system is to be solved using pdpttrs after the factorizatio pdstedc computes all eigenvalues and eigenvectors of a symmetric tridiagonal matrix in parallel, using the divide an pdstein computes the eigenvectors of a symmetric tridiagonal matrix in parallel, using inverse iteration. the eigenvectors foun orthogonalize vectors that are on different processes. the extent computers. users are encouraged to modify this subroutine to set the tuning parameters for their particular machine using the optio if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. psdbtrf and this is stored in af. if a linear system is to be solved using psdbtrs after the factorizatio if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. psdttrf and this is stored in af. if a linear system is to be solved using psdttrs after the factorizatio if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. psgbtrf and this is stored in af. if a linear system is to be solved using psgbtrs after the factorizatio distributed real matrix a(ia:ia+n-1,ja:ja+n-1), in either the 1-norm or the infinity-norm, using the lu factorization computed by psgetrf an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), and systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1), or its transpose, using a qr or lq factorization of sub( a ). it i workspaces required respectively for the subprograms pslange, pslared1d, pslared2d, psgebrd. using th 4. the system of equations is solved for x using the factored for psgetf2 computes an lu factorization of a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using psgetrf computes an lu factorization of a general m-by-n distributed matrix sub( a ) = (ia:ia+m-1,ja:ja+n-1) using partial pivoting wit psgetri computes the inverse of a distributed matrix using the l computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted with a general n-by-n distributed matrix sub( a ) using the l sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a or a**t and v and the nb-by-n matrix u' which are needed, with x and y, to apply the transformation to the unreduced part of the matrix, using a bloc ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. pslaed0 computes all eigenvalues and corresponding eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method the final stage consists of computing the updated eigenvectors directly using the updated eigenvalues. the eigenvectors fo the overall problem. v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an update of the form pslaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scalin pslaqsy equilibrates a symmetric distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in th which is needed, with w, to apply the transformation to the unreduced part of the matrix, using a symmetric rank-2k update of the form if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pspbtrf and this is stored in af. if a linear system is to be solved using pspbtrs after the factorizatio 1-norm) of a real symmetric positive definite distributed matrix using the cholesky factorization a = u**t*u or a = l*l**t computed b 4. the system of equations is solved for x using the factored for pspotri computes the inverse of a real symmetric positive definite distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using th pspotrf. where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a n-by-n symmetric positive definite distributed matrix using the cholesk sub( b ) denotes the distributed matrix b(ib:ib+n-1,jb:jb+nrhs-1). if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pspttrf and this is stored in af. if a linear system is to be solved using pspttrs after the factorizatio psstedc computes all eigenvalues and eigenvectors of a symmetric tridiagonal matrix in parallel, using the divide an psstein computes the eigenvectors of a symmetric tridiagonal matrix in parallel, using inverse iteration. the eigenvectors foun orthogonalize vectors that are on different processes. the extent if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pzdbtrf and this is stored in af. if a linear system is to be solved using pzdbtrs after the factorizatio if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pzdttrf and this is stored in af. if a linear system is to be solved using pzdttrs after the factorizatio if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pzgbtrf and this is stored in af. if a linear system is to be solved using pzgbtrs after the factorizatio distributed complex matrix a(ia:ia+n-1,ja:ja+n-1), in either the 1-norm or the infinity-norm, using the lu factorization computed b systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1), or its conjugate-transpose, using a qr or lq factorization o workspaces required respectively for the subprograms pzlange, pdlared1d, pdlared2d, pzgebrd. using th 4. the system of equations is solved for x using the factored for pzgetf2 computes an lu factorization of a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using pzgetrf computes an lu factorization of a general m-by-n distributed matrix sub( a ) = (ia:ia+m-1,ja:ja+n-1) using partial pivoting wit pzgetri computes the inverse of a distributed matrix using the l computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted with a general n-by-n distributed matrix sub( a ) using the l sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a, a**t or a**h pzheevd computes all the eigenvalues and eigenvectors of a hermitian matrix a by using a divide and conquer algorithm arguments v and the nb-by-n matrix u' which are needed, with x and y, to apply the transformation to the unreduced part of the matrix, using a bloc ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. v which is needed, with t and y, to apply the transformation to the unreduced part of the matrix, using an update of the form pzlaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scalin pzlaqsy equilibrates a symmetric distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in th which is needed, with w, to apply the transformation to the unreduced part of the matrix, using a hermitian rank-2k update of the form if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pzpbtrf and this is stored in af. if a linear system is to be solved using pzpbtrs after the factorizatio 1-norm) of a complex hermitian positive definite distributed matrix using the cholesky factorization a = u**h*u or a = l*l**h computed b 4. the system of equations is solved for x using the factored for pzpotri computes the inverse of a complex hermitian positive definite distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using th pzpotrf. where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a n-by-n hermitian positive definite distributed matrix using the cholesk sub( b ) denotes the distributed matrix b(ib:ib+n-1,jb:jb+nrhs-1). if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the sam between calls to the factorization routine and the solve routine. pzpttrf and this is stored in af. if a linear system is to be solved using pzpttrs after the factorizatio pzstein computes the eigenvectors of a symmetric tridiagonal matrix in parallel, using inverse iteration. the eigenvectors foun orthogonalize vectors that are on different processes. the extent = 'b': compute all right and/or left eigenvectors, and backtransform them using the input matrice = 's': compute selected right and/or left eigenvectors, sdbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. sdttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form zdbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. zdttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form |
| usually usually note that for mycol > 0 one has lower triangular blocks! lm is the number of rows which is usually nb except fo is nr+bwu where nr is the number of columns on the last processor on entry, if side = 'l' or 'b' and howmny = 'b', vl must contain an n-by-n matrix q (usually the unitary matrix q o on exit, if side = 'l' or 'b', vl contains: note that for mycol > 0 one has lower triangular blocks! lm is the number of rows which is usually nb except fo is nr+bwu where nr is the number of columns on the last processor note that for mycol > 0 one has lower triangular blocks! lm is the number of rows which is usually nb except fo is nr+bwu where nr is the number of columns on the last processor note that for mycol > 0 one has lower triangular blocks! lm is the number of rows which is usually nb except fo is nr+bwu where nr is the number of columns on the last processor on entry, if side = 'l' or 'b' and howmny = 'b', vl must contain an n-by-n matrix q (usually the unitary matrix q o on exit, if side = 'l' or 'b', vl contains: |
| utility utility call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri call utility routine that forms "standard-form" gri |
| utk utk in ifail. ensure abstol=2.0*pslamch( 'u' ) send e-mail to scalapack@cs.utk.ed to one or more clusters of eigenvalues could not be failed to converge. their indices are stored in ifail. send e-mail to scalapack@cs.utk.ed to one or more clusters of eigenvalues could not be in ifail. ensure abstol=2.0*pdlamch( 'u' ) send e-mail to scalapack@cs.utk.ed to one or more clusters of eigenvalues could not be failed to converge. their indices are stored in ifail. send e-mail to scalapack@cs.utk.ed to one or more clusters of eigenvalues could not be in ifail. ensure abstol=2.0*pslamch( 'u' ) send e-mail to scalapack@cs.utk.ed to one or more clusters of eigenvalues could not be failed to converge. their indices are stored in ifail. send e-mail to scalapack@cs.utk.ed to one or more clusters of eigenvalues could not be in ifail. ensure abstol=2.0*pdlamch( 'u' ) send e-mail to scalapack@cs.utk.ed to one or more clusters of eigenvalues could not be failed to converge. their indices are stored in ifail. send e-mail to scalapack@cs.utk.ed to one or more clusters of eigenvalues could not be |
| UTN UTN trans = 't', and diag = 'n' for a triangular routine would be specified as opts = 'UTN' n1 (global input) integer |