Back| S- |
| safe safe r(i) and c(j) are restricted to be between smlnum = smallest safe factors is not guaranteed to reduce the condition number of r(i) and c(j) are restricted to be between smlnum = smallest safe factors is not guaranteed to reduce the condition number of eps = relative machine precision sfmin = safe minimum, such that 1/sfmin does not overflo prec = eps*base r(i) and c(j) are restricted to be between smlnum = smallest safe factors is not guaranteed to reduce the condition number of eps = relative machine precision sfmin = safe minimum, such that 1/sfmin does not overflo prec = eps*base r(i) and c(j) are restricted to be between smlnum = smallest safe factors is not guaranteed to reduce the condition number of |
| safe_min safe_min implementation of the sturm sequence loop. this must be at least max_j |e(j)^2| *safe_min, and at least safe_min, wher without overflow. implementation of the sturm sequence loop. this must be at least max_j |e(j)^2| *safe_min, and at least safe_min, wher without overflow. implementation of the sturm sequence loop. this must be at least max_j |e(j)^2| *safe_min, and at least safe_min, wher without overflow. implementation of the sturm sequence loop. this must be at least max_j |e(j)^2| *safe_min, and at least safe_min, wher without overflow. |
| safely safely pclasmsub looks for a small subdiagonal element from the bottom of the matrix that it can safely set to zero notes pdlasmsub looks for a small subdiagonal element from the bottom of the matrix that it can safely set to zero notes pslasmsub looks for a small subdiagonal element from the bottom of the matrix that it can safely set to zero notes pzlasmsub looks for a small subdiagonal element from the bottom of the matrix that it can safely set to zero notes |
| SAFMIN SAFMIN gp = ( ( oldgp+p )-( d( l )-p ) ) / $ ( two*( c*oldrp-b )+SAFMIN gp = ( ( oldgp+p )-( d( l )-p ) ) / $ ( two*( c*oldrp-b )+SAFMIN |
| same same lihiz (local input) integer these serve the same purpose as itmp1,itmp2 but for lihiz (local input) integer these serve the same purpose as itmp1,itmp2 but for if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. element (l,ln+1) is swapped with element (j,ln+1) etc furthermore, the elements in the same row are ldb=llda-1 apar data format: if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. the distributed submatrices op( a ) and op( af ) (respectively sub( x ) and sub( b ) ) should be distributed the same way on th (resp. sub( x ) and sub( b ) ) are "perfectly" aligned. on exit, if info = 0, the transformed matrix, stored in the same format as sub( a ) ia (global input) integer on exit, if info = 0, the transformed matrix, stored in the same format as sub( a ) ia (global input) integer pchengst performs the same function as pchegst, but is based o triangular solves (the basis of pchengst). liip1 and ltlip1) is subtle. within the current processor column (i.e. mycol .eq. curcol) they are the same. however above the diagonal, on these processors, ltli = lii+1. 2.) the small work it takes so that each of the rows and columns is at the same place. for example through some column tmp. (loops 250-260) 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, us if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed the distributed submatrices op( a ) and op( af ) (respectively sub( x ) and sub( b ) ) should be distributed the same way on th (resp. sub( x ) and sub( b ) ) are "perfectly" aligned. contains the triangular factor u or l from the cholesky factorization a = u**t*u or a = l*l**t, in the same storag of the equilibrated matrix diag(sr)*a*diag(sc). if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed of orthogonalization is controlled by the input parameter lwork. eigenvectors that are to be orthogonalized are computed by the same processes and then calls sstein2 (modified lapack routine) on each select, stored consecutively in the columns of vl, in the same order as thei if side = 'r', vl is not referenced. the distributed submatrices sub( x ) and sub( b ) should be distributed the same way on the same processes. these condition to be 1. on exit, the (triangular) inverse of the original matrix, in the same storage format ia (global input) integer ihi (global input) integer ilo and ihi must have the same values as in the previous cal distributed submatrix q(ia+ilo:ia+ihi-1,ia+ilo:ja+ihi-1). if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. element (l,ln+1) is swapped with element (j,ln+1) etc furthermore, the elements in the same row are ldb=llda-1 apar data format: if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. the distributed submatrices op( a ) and op( af ) (respectively sub( x ) and sub( b ) ) should be distributed the same way on th (resp. sub( x ) and sub( b ) ) are "perfectly" aligned. 2.) the small work it takes so that each of the rows and columns is at the same place. for example through some column tmp. (loops within 190) it assumes that the input array, bycol, is distributed across rows and that all process columns contain the same copy o and will contain the entire array. it assumes that the input array, byrow, is distributed across columns and that all process rows contain the same copy o and will contain the entire array. 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, us ihi (global input) integer ilo and ihi must have the same values as in the previous cal distributed submatrix q(ia+ilo:ia+ihi-1,ia+ilo:ja+ihi-1). if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed the distributed submatrices op( a ) and op( af ) (respectively sub( x ) and sub( b ) ) should be distributed the same way on th (resp. sub( x ) and sub( b ) ) are "perfectly" aligned. contains the triangular factor u or l from the cholesky factorization a = u**t*u or a = l*l**t, in the same storag of the equilibrated matrix diag(sr)*a*diag(sc). if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed of orthogonalization is controlled by the input parameter lwork. eigenvectors that are to be orthogonalized are computed by the same processes and then calls dstein2 (modified lapack routine) on each on exit, if info = 0, the transformed matrix, stored in the same format as sub( a ) ia (global input) integer on exit, if info = 0, the transformed matrix, stored in the same format as sub( a ) ia (global input) integer pdsyngst performs the same function as pdhegst, but is based o triangular solves (the basis of pdsyngst). liip1 and ltlip1) is subtle. within the current processor column (i.e. mycol .eq. curcol) they are the same. however above the diagonal, on these processors, ltli = lii+1. the distributed submatrices sub( x ) and sub( b ) should be distributed the same way on the same processes. these condition to be 1. on exit, the (triangular) inverse of the original matrix, in the same storage format ia (global input) integer most parameters set via a call to pjlaenv must be identical on all processors and hence pjlaenv will return the same in particular, the panel blocking factor can be different if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. element (l,ln+1) is swapped with element (j,ln+1) etc furthermore, the elements in the same row are ldb=llda-1 apar data format: if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. the distributed submatrices op( a ) and op( af ) (respectively sub( x ) and sub( b ) ) should be distributed the same way on th (resp. sub( x ) and sub( b ) ) are "perfectly" aligned. 2.) the small work it takes so that each of the rows and columns is at the same place. for example through some column tmp. (loops within 190) it assumes that the input array, bycol, is distributed across rows and that all process columns contain the same copy o and will contain the entire array. it assumes that the input array, byrow, is distributed across columns and that all process rows contain the same copy o and will contain the entire array. 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, us ihi (global input) integer ilo and ihi must have the same values as in the previous cal distributed submatrix q(ia+ilo:ia+ihi-1,ia+ilo:ja+ihi-1). if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed the distributed submatrices op( a ) and op( af ) (respectively sub( x ) and sub( b ) ) should be distributed the same way on th (resp. sub( x ) and sub( b ) ) are "perfectly" aligned. contains the triangular factor u or l from the cholesky factorization a = u**t*u or a = l*l**t, in the same storag of the equilibrated matrix diag(sr)*a*diag(sc). if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed of orthogonalization is controlled by the input parameter lwork. eigenvectors that are to be orthogonalized are computed by the same processes and then calls sstein2 (modified lapack routine) on each on exit, if info = 0, the transformed matrix, stored in the same format as sub( a ) ia (global input) integer on exit, if info = 0, the transformed matrix, stored in the same format as sub( a ) ia (global input) integer pssyngst performs the same function as pshegst, but is based o triangular solves (the basis of pssyngst). liip1 and ltlip1) is subtle. within the current processor column (i.e. mycol .eq. curcol) they are the same. however above the diagonal, on these processors, ltli = lii+1. the distributed submatrices sub( x ) and sub( b ) should be distributed the same way on the same processes. these condition to be 1. on exit, the (triangular) inverse of the original matrix, in the same storage format ia (global input) integer if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. element (l,ln+1) is swapped with element (j,ln+1) etc furthermore, the elements in the same row are ldb=llda-1 apar data format: if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. the distributed submatrices op( a ) and op( af ) (respectively sub( x ) and sub( b ) ) should be distributed the same way on th (resp. sub( x ) and sub( b ) ) are "perfectly" aligned. on exit, if info = 0, the transformed matrix, stored in the same format as sub( a ) ia (global input) integer on exit, if info = 0, the transformed matrix, stored in the same format as sub( a ) ia (global input) integer pzhengst performs the same function as pzhegst, but is based o triangular solves (the basis of pzhengst). liip1 and ltlip1) is subtle. within the current processor column (i.e. mycol .eq. curcol) they are the same. however above the diagonal, on these processors, ltli = lii+1. 2.) the small work it takes so that each of the rows and columns is at the same place. for example through some column tmp. (loops 250-260) 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, us if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed the distributed submatrices op( a ) and op( af ) (respectively sub( x ) and sub( b ) ) should be distributed the same way on th (resp. sub( x ) and sub( b ) ) are "perfectly" aligned. contains the triangular factor u or l from the cholesky factorization a = u**t*u or a = l*l**t, in the same storag of the equilibrated matrix diag(sr)*a*diag(sc). if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. if the factorization routine and the solve routine are to be called separately (to solve various sets of righthand sides using the same between calls to the factorization routine and the solve routine. context must be the same these are alignment restrictions that may or may not be removed of orthogonalization is controlled by the input parameter lwork. eigenvectors that are to be orthogonalized are computed by the same processes and then calls dstein2 (modified lapack routine) on each select, stored consecutively in the columns of vl, in the same order as thei if side = 'r', vl is not referenced. the distributed submatrices sub( x ) and sub( b ) should be distributed the same way on the same processes. these condition to be 1. on exit, the (triangular) inverse of the original matrix, in the same storage format ia (global input) integer ihi (global input) integer ilo and ihi must have the same values as in the previous cal distributed submatrix q(ia+ilo:ia+ihi-1,ia+ilo:ja+ihi-1). lihiz (local input) integer these serve the same purpose as itmp1,itmp2 but for lihiz (local input) integer these serve the same purpose as itmp1,itmp2 but for |
| satisfied satisfied if stopping criterion was not satisfied, update info an if stopping criterion was not satisfied, update info an |
| satisfy satisfy on exit, this yields the starting location of the qr double shift. this will satisfy: l <= m <= i-2 h44 on exit, this yields the bottom portion of the unreduced submatrix. this will satisfy: l <= m <= i-1 smlnum (global input) real the value of sumsq is assumed to be at least unity and the value of ssq will then satisfy 1.0 .le. ssq .le. ( sumsq + 2*n ). on exit, this yields the starting location of the qr double shift. this will satisfy: l <= m <= i-2 h44 on exit, this yields the bottom portion of the unreduced submatrix. this will satisfy: l <= m <= i-1 smlnum (global input) double precision on exit, this yields the starting location of the qr double shift. this will satisfy: l <= m <= i-2 h44 on exit, this yields the bottom portion of the unreduced submatrix. this will satisfy: l <= m <= i-1 smlnum (global input) real on exit, this yields the starting location of the qr double shift. this will satisfy: l <= m <= i-2 h44 on exit, this yields the bottom portion of the unreduced submatrix. this will satisfy: l <= m <= i-1 smlnum (global input) double precision the value of sumsq is assumed to be at least unity and the value of ssq will then satisfy 1.0 .le. ssq .le. ( sumsq + 2*n ). |
| Save Save if eigenvectors are desired, then Save rotations Save the shift to check eigenvalue spacing at nex if eigenvectors are desired, then Save rotations Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save and compute new value of n Save the shift to check eigenvalue spacing at nex if eigenvectors are desired, then Save rotations if eigenvectors are desired, then Save rotations |
| saved saved if eigenvectors are desired, then apply saved rotations if eigenvectors are desired, then apply saved rotations restore saved input parameter restore saved input parameter restore saved input parameter restore saved input parameter restore saved input parameter restore saved input parameter if eigenvectors are desired, then apply saved rotations if eigenvectors are desired, then apply saved rotations |
| says says tolerances. this is generally caused by arithmetic which is less accurate than pdlamch says eigenvalues output and the number desired. tolerances. this is generally caused by arithmetic which is less accurate than pslamch says eigenvalues output and the number desired. |
| SBDSQR SBDSQR wbdtosvd = size*(wantu*nru + wantvt*ncvt) + max(wSBDSQR |
| scalable scalable 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 |
| Scalapack Scalapack used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details used in lapack. please see the notes below and the Scalapack manual for more detail on the format o descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details finally aptr is the pointer to the first element of a. as lapack has a slightly different matrix format than Scalapack the pointe used in lapack. please see the notes below and the Scalapack manual for more detail on the format o the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). row. the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). of a real symmetric matrix a by calling the recommended sequence of Scalapack routines in its present form, pcheev assumes a homogeneous system and makes of a complex hermitian matrix a by calling the recommended sequence of Scalapack routines. eigenvalues/vectors can be selected b eigenvalues. the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locp() and locq() may be determined via a call to the Scalapack tool function, numroc locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). pclaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a Scalapack standard block cycli the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details used in lapack. please see the notes below and the Scalapack manual for more detail on the format o the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details used in lapack. please see the notes below and the Scalapack manual for more detail on the format o descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details finally aptr is the pointer to the first element of a. as lapack has a slightly different matrix format than Scalapack the pointe used in lapack. please see the notes below and the Scalapack manual for more detail on the format o the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). row. the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). this is a Scalapack internal subroutine and arguments are no this is a Scalapack internal procedure and arguments are not checke pdlaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a Scalapack standard block cycli the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). this is a Scalapack internal procedure and arguments are not checke the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details used in lapack. please see the notes below and the Scalapack manual for more detail on the format o the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). of a real symmetric matrix a by calling the recommended sequence of Scalapack routines in its present form, pdsyev assumes a homogeneous system and makes of a real symmetric matrix a by calling the recommended sequence of Scalapack routines in its present form, pdsyevd assumes a homogeneous system and makes of a real symmetric matrix a by calling the recommended sequence of Scalapack routines. eigenvalues/vectors can be selected b eigenvalues. the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locp() and locq() may be determined via a call to the Scalapack tool function, numroc locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). pjlaenv is called from the Scalapack symmetric and hermitia problem-dependent parameters for the local environment. see ispec the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details used in lapack. please see the notes below and the Scalapack manual for more detail on the format o descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details finally aptr is the pointer to the first element of a. as lapack has a slightly different matrix format than Scalapack the pointe used in lapack. please see the notes below and the Scalapack manual for more detail on the format o the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). row. the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). this is a Scalapack internal subroutine and arguments are no this is a Scalapack internal procedure and arguments are not checke pslaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a Scalapack standard block cycli the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). this is a Scalapack internal procedure and arguments are not checke the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details used in lapack. please see the notes below and the Scalapack manual for more detail on the format o the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). of a real symmetric matrix a by calling the recommended sequence of Scalapack routines in its present form, pssyev assumes a homogeneous system and makes of a real symmetric matrix a by calling the recommended sequence of Scalapack routines in its present form, pssyevd assumes a homogeneous system and makes of a real symmetric matrix a by calling the recommended sequence of Scalapack routines. eigenvalues/vectors can be selected b eigenvalues. the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locp() and locq() may be determined via a call to the Scalapack tool function, numroc locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details used in lapack. please see the notes below and the Scalapack manual for more detail on the format o the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details finally aptr is the pointer to the first element of a. as lapack has a slightly different matrix format than Scalapack the pointe used in lapack. please see the notes below and the Scalapack manual for more detail on the format o the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). row. the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). of a real symmetric matrix a by calling the recommended sequence of Scalapack routines in its present form, pzheev assumes a homogeneous system and makes of a complex hermitian matrix a by calling the recommended sequence of Scalapack routines. eigenvalues/vectors can be selected b eigenvalues. the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locp() and locq() may be determined via a call to the Scalapack tool function, numroc locq( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). pzlaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a Scalapack standard block cycli the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). used in lapack. please see the notes below and the Scalapack manual for more detail on the format o on exit, this array contains information containing details used in lapack. please see the notes below and the Scalapack manual for more detail on the format o the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional descriptors now have *types* and differ from Scalapack 1.0 note: tridiagonal codes can use either the old two dimensional the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). the values of locr() and locc() may be determined via a call to the Scalapack tool function, numroc locc( n ) = numroc( n, nb_a, mycol, csrc_a, npcol ). |
| scalapack@cs scalapack@cs 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 |
| scalar scalar an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tauq (local output) complex array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar tied to the distributed matrix a. see further details. tauq (local output) complex array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar tied to the distributed matrix a. see further details. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, and i is tau (local output) complex array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe set to zero. tau is tied to the distributed matrix a. tau (local output) complex array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe set to zero. tau is tied to the distributed matrix a. tau (local output) complex, array, dimension locr(ia+min(m,n)-1). this array contains the scalar factor matrix a. tau (local output) complex, array, dimension locr(ia+min(m,n)-1). this array contains the scalar factor matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) complex, array, dimension locc(ja+n-1) this array contains the scalar factors of the elementar tau (local output) complex, array, dimension locc(ja+n-1) this array contains the scalar factors of the elementar tau (local output) complex, array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. tau (local output) complex, array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. tau (local output) complex, array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) complex, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar tau (local output) complex, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. .. scalar arguments . .. array arguments .. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ia+k-1) is exactly zero; the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the taua (local output) complex, array, dimension locc(ja+min(n,m)-1). this array contains the scalar factor matrix q. taua is tied to the distributed matrix a. (see taua (local output) complex, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar tied to the distributed matrix a (see further details). an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = 1 through n, the i(th) eigenvalue did not an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = 1 through n, the i(th) eigenvalue did not an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if (mod(info,2).ne.0), then one or more eigenvectors an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if (mod(info,2).ne.0), then one or more eigenvectors an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) complex, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) complex, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) complex, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) complex, array, dimension locq(ja+n-1). this array contains the scalar factors tau o matrix a. tauq (local output) complex array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar tied to the distributed matrix a. see further details. tau (local output) complex array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe where alpha is a real scalar, and sub( x ) is an (n-1)-elemen x(ix,jx:jx+n-2) if incx = descx(m_). h is represented in the form pclascl multiplies the m-by-n complex distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. thi cto * a(i,j) / cfrom does not over/underflow. type specifies that tau (local output) complex, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) complex, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar when the result of a vector-oriented pblas call is a scalar, it wil being operated on. let x be a generic term for the input vector(s). an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the k-th diagonal entry of sub( a ) is an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, the (i,i) element of the factor u or l is an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the pcsrscl multiplies an n-element complex distributed vector sub( x ) by the real scalar 1/a. this is done without overflow o underflow. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the < 0 : if info = -i, the i-th argument had an illegal value an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, a(ia+k-1,ja+k-1) is exactly zero. the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, the i-th diagonal element of sub( a ) is tau (local output) complex, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar tau (local input) complex, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locr(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locr(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ja+k-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locr(ia+m-1) this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locr(ia+m-1) this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. locc(ja+min(nq,k)-1) if vect = 'q', locr(ia+min(nq,k)-1) if vect = 'p', tau(i) must contain the scalar factor of th as returned by pdgebrd in its array argument tauq or taup. if side = 'l', and locc(ja+n-2) if side = 'r'. this array contains the scalar factors tau(j) of the elementar the distributed matrix a. tau (local input) complex, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. if side = 'r' and uplo = 'l', ltau = locc(ja+n-2). tau(i) must contain the scalar factor of the elementar distributed matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tauq (local output) double precision array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar is tied to the distributed matrix a. see further details. tauq (local output) double precision array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar is tied to the distributed matrix a. see further details. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, and i is tau (local output) double precision array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe set to zero. tau is tied to the distributed matrix a. tau (local output) double precision array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe set to zero. tau is tied to the distributed matrix a. tau (local output) double precision array, dimension locr(ia+min(m,n)-1). this array contains the scalar factor matrix a. tau (local output) double precision array, dimension locr(ia+min(m,n)-1). this array contains the scalar factor matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) double precision array, dimension locc(ja+n-1) this array contains the scalar factors of the elementar tau (local output) double precision array, dimension locc(ja+n-1) this array contains the scalar factors of the elementar tau (local output) double precision array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. tau (local output) double precision array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. tau (local output) double precision array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) double precision array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar tau (local output) double precision array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. .. scalar arguments . .. array arguments .. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ia+k-1) is exactly zero; the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the taua (local output) double precision array, dimension locc(ja+min(n,m)-1). this array contains the scalar factor orthogonal matrix q. taua is tied to the distributed matrix taua (local output) double precision array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar taua is tied to the distributed matrix a (see further tauq (local output) double precision array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar is tied to the distributed matrix a. see further details. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: the algorithm failed to compute the info/(n+1) th an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: the algorithm failed to compute the ith eigenvalue. tau (local output) double precision array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe where alpha is a scalar, and sub( x ) is an (n-1)-element rea incx = descx(m_). h is represented in the form pdlascl multiplies the m-by-n real distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. thi cto * a(i,j) / cfrom does not over/underflow. type specifies that an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) double precision array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) double precision array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar tau (local input) double precision array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locr(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locr(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ja+k-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locr(ia+m-1) this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locr(ia+m-1) this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. locc(ja+min(nq,k)-1) if vect = 'q', locr(ia+min(nq,k)-1) if vect = 'p', tau(i) must contain the scalar factor of th as returned by pdgebrd in its array argument tauq or taup. if side = 'l', and locc(ja+n-2) if side = 'r'. this array contains the scalar factors tau(j) of the elementar the distributed matrix a. tau (local input) double precision array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) double precision array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. if side = 'r' and uplo = 'l', ltau = locc(ja+n-2). tau(i) must contain the scalar factor of the elementar distributed matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the k-th diagonal entry of sub( a ) is an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, the (i,i) element of the factor u or l is an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the pdrscl multiplies an n-element real distributed vector sub( x ) by the real scalar 1/a. this is done without overflow or underflow a an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: the algorithm failed to compute the info/(n+1) th an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the < 0 : if info = -i, the i-th argument had an illegal value an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = 1 through n, the i(th) eigenvalue did not an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: the algorithm failed to compute the info/(n+1) th an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if (mod(info,2).ne.0), then one or more eigenvectors an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if (mod(info,2).ne.0), then one or more eigenvectors an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) double precision array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) double precision array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) double precision array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) double precision array, dimension locq(ja+n-1). this array contains the scalar factors tau o matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, a(ia+k-1,ja+k-1) is exactly zero. the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, the i-th diagonal element of sub( a ) is tau (local output) double precision array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar when the result of a vector-oriented pblas call is a scalar, it wil being operated on. let x be a generic term for the input vector(s). when the result of a vector-oriented pblas call is a scalar, it wil being operated on. let x be a generic term for the input vector(s). an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tauq (local output) real array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar is tied to the distributed matrix a. see further details. tauq (local output) real array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar is tied to the distributed matrix a. see further details. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, and i is tau (local output) real array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe set to zero. tau is tied to the distributed matrix a. tau (local output) real array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe set to zero. tau is tied to the distributed matrix a. tau (local output) real, array, dimension locr(ia+min(m,n)-1). this array contains the scalar factor matrix a. tau (local output) real, array, dimension locr(ia+min(m,n)-1). this array contains the scalar factor matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) real, array, dimension locc(ja+n-1) this array contains the scalar factors of the elementar tau (local output) real, array, dimension locc(ja+n-1) this array contains the scalar factors of the elementar tau (local output) real, array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. tau (local output) real, array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. tau (local output) real, array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) real, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar tau (local output) real, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. .. scalar arguments . .. array arguments .. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ia+k-1) is exactly zero; the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the taua (local output) real, array, dimension locc(ja+min(n,m)-1). this array contains the scalar factor orthogonal matrix q. taua is tied to the distributed matrix taua (local output) real, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar taua is tied to the distributed matrix a (see further tauq (local output) real array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar is tied to the distributed matrix a. see further details. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: the algorithm failed to compute the info/(n+1) th an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: the algorithm failed to compute the ith eigenvalue. tau (local output) real array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe where alpha is a scalar, and sub( x ) is an (n-1)-element rea incx = descx(m_). h is represented in the form pslascl multiplies the m-by-n real distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. thi cto * a(i,j) / cfrom does not over/underflow. type specifies that an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) real, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) real, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar tau (local input) real, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locr(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locr(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ja+k-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locr(ia+m-1) this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locr(ia+m-1) this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. locc(ja+min(nq,k)-1) if vect = 'q', locr(ia+min(nq,k)-1) if vect = 'p', tau(i) must contain the scalar factor of th as returned by pdgebrd in its array argument tauq or taup. if side = 'l', and locc(ja+n-2) if side = 'r'. this array contains the scalar factors tau(j) of the elementar the distributed matrix a. tau (local input) real, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) real, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. if side = 'r' and uplo = 'l', ltau = locc(ja+n-2). tau(i) must contain the scalar factor of the elementar distributed matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the k-th diagonal entry of sub( a ) is an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, the (i,i) element of the factor u or l is an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the psrscl multiplies an n-element real distributed vector sub( x ) by the real scalar 1/a. this is done without overflow or underflow a an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: the algorithm failed to compute the info/(n+1) th an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the < 0 : if info = -i, the i-th argument had an illegal value an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = 1 through n, the i(th) eigenvalue did not an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: the algorithm failed to compute the info/(n+1) th an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if (mod(info,2).ne.0), then one or more eigenvectors an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if (mod(info,2).ne.0), then one or more eigenvectors an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) real, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) real, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) real, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) real, array, dimension locq(ja+n-1). this array contains the scalar factors tau o matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, a(ia+k-1,ja+k-1) is exactly zero. the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, the i-th diagonal element of sub( a ) is tau (local output) real, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the pzdrscl multiplies an n-element complex distributed vector sub( x ) by the real scalar 1/a. this is done without overflow o underflow. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tauq (local output) complex*16 array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar tied to the distributed matrix a. see further details. tauq (local output) complex*16 array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar tied to the distributed matrix a. see further details. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, and i is tau (local output) complex*16 array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe set to zero. tau is tied to the distributed matrix a. tau (local output) complex*16 array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe set to zero. tau is tied to the distributed matrix a. tau (local output) complex*16, array, dimension locr(ia+min(m,n)-1). this array contains the scalar factor matrix a. tau (local output) complex*16, array, dimension locr(ia+min(m,n)-1). this array contains the scalar factor matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) complex*16, array, dimension locc(ja+n-1) this array contains the scalar factors of the elementar tau (local output) complex*16, array, dimension locc(ja+n-1) this array contains the scalar factors of the elementar tau (local output) complex*16, array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. tau (local output) complex*16, array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. tau (local output) complex*16, array, dimension locc(ja+min(m,n)-1). this array contains the scalar factor distributed matrix a. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) complex*16, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar tau (local output) complex*16, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. .. scalar arguments . .. array arguments .. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ja+k-1) is exactly zero. an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, u(ia+k-1,ia+k-1) is exactly zero; the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the taua (local output) complex*16, array, dimension locc(ja+min(n,m)-1). this array contains the scalar factor matrix q. taua is tied to the distributed matrix a. (see taua (local output) complex*16, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar tied to the distributed matrix a (see further details). an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = 1 through n, the i(th) eigenvalue did not an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = 1 through n, the i(th) eigenvalue did not an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if (mod(info,2).ne.0), then one or more eigenvectors an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if (mod(info,2).ne.0), then one or more eigenvectors an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the tau (local output) complex*16, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) complex*16, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) complex*16, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) complex*16, array, dimension locq(ja+n-1). this array contains the scalar factors tau o matrix a. tauq (local output) complex*16 array dimension locc(ja+min(m,n)-1). the scalar factors of the elementar tied to the distributed matrix a. see further details. tau (local output) complex*16 array, dimension locc(ja+n-2) the scalar factors of the elementary reflectors (see furthe where alpha is a real scalar, and sub( x ) is an (n-1)-elemen x(ix,jx:jx+n-2) if incx = descx(m_). h is represented in the form pzlascl multiplies the m-by-n complex distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. thi cto * a(i,j) / cfrom does not over/underflow. type specifies that tau (local output) complex*16, array, dimension locc(ja+n-1). this array contains the scalar factors tau o matrix a. tau (local output) complex*16, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar when the result of a vector-oriented pblas call is a scalar, it wil being operated on. let x be a generic term for the input vector(s). an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the k-th diagonal entry of sub( a ) is an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, the leading minor of order k, an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, the (i,i) element of the factor u or l is an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k<=nprocs, the submatrix stored on processor an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the < 0 : if info = -i, the i-th argument had an illegal value an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = k, a(ia+k-1,ja+k-1) is exactly zero. the an illegal value, then info = -(i*100+j), if the i-th argument is a scalar and had an illegal value, the > 0: if info = i, the i-th diagonal element of sub( a ) is tau (local output) complex*16, array, dimension locr(ia+m-1) this array contains the scalar factors of the elementar tau (local input) complex*16, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locr(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locr(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ja+k-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locr(ia+m-1) this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locr(ia+m-1) this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. locc(ja+min(nq,k)-1) if vect = 'q', locr(ia+min(nq,k)-1) if vect = 'p', tau(i) must contain the scalar factor of th as returned by pdgebrd in its array argument tauq or taup. if side = 'l', and locc(ja+n-2) if side = 'r'. this array contains the scalar factors tau(j) of the elementar the distributed matrix a. tau (local input) complex*16, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ja+n-1) this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ja+k-1). this array contains the scalar factors tau(j) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. tau (local input) complex*16, array, dimension locc(ia+k-1). this array contains the scalar factors tau(i) of th tau is tied to the distributed matrix a. if side = 'r' and uplo = 'l', ltau = locc(ja+n-2). tau(i) must contain the scalar factor of the elementar distributed matrix a. |
| Scalars Scalars .. .. local Scalars . .. local arrays .. .. local Scalars . .. local Scalars . .. .. local Scalars . .. local arrays .. .. local Scalars . .. local Scalars . .. local Scalars . .. .. local Scalars . .. local arrays .. .. local Scalars . .. local Scalars . .. .. local Scalars . .. local arrays .. .. local Scalars . .. .. local Scalars . .. local arrays .. .. local Scalars . .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. external functions .. .. local Scalars . .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. where tauq and taup are complex Scalars, and v and u are comple v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in where tauq and taup are complex Scalars, and v and u are comple v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in where tauq and taup are complex Scalars, and v and u are comple .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. external subroutines .. .. .. local Scalars . .. external subroutines .. if incx = 1, and locr(ix) otherwise. this array contains the householder Scalars related to the householder vectors if incv = m_v, and locc(jv+k-1) otherwise. this array contains the householder Scalars related to the householde .. .. local Scalars . .. external subroutines .. .. .. local Scalars . .. external subroutines .. if incv = m_v, and locc(jv+k-1) otherwise. this array contains the householder Scalars related to the householde .. local Scalars . .. external functions .. .. .. local Scalars . .. external functions .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. where tauq and taup are real Scalars, and v and u are real vectors a(ia+i:ia+m-1,ja+i-1); where tauq and taup are real Scalars, and v and u are real vectors a(ia+i:ia+m-1,ja+i-1); .. local Scalars . where tauq and taup are real Scalars, and v and u are real vectors if m >= n, v(1:i-1) = 0, v(i) = 1, and v(i:m) is stored on exit in .. .. local Scalars . .. local arrays .. .. local Scalars . .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. external subroutines .. if incx = 1, and locr(ix) otherwise. this array contains the householder Scalars related to the householder vectors if incv = m_v, and locc(jv+k-1) otherwise. this array contains the householder Scalars related to the householde .. .. local Scalars . .. external subroutines .. if incv = m_v, and locc(jv+k-1) otherwise. this array contains the householder Scalars related to the householde .. local Scalars . .. external functions .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. where tauq and taup are real Scalars, and v and u are real vectors a(ia+i:ia+m-1,ja+i-1); where tauq and taup are real Scalars, and v and u are real vectors a(ia+i:ia+m-1,ja+i-1); .. local Scalars . where tauq and taup are real Scalars, and v and u are real vectors if m >= n, v(1:i-1) = 0, v(i) = 1, and v(i:m) is stored on exit in .. .. local Scalars . .. local arrays .. .. local Scalars . .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. external subroutines .. if incx = 1, and locr(ix) otherwise. this array contains the householder Scalars related to the householder vectors if incv = m_v, and locc(jv+k-1) otherwise. this array contains the householder Scalars related to the householde .. .. local Scalars . .. external subroutines .. if incv = m_v, and locc(jv+k-1) otherwise. this array contains the householder Scalars related to the householde .. local Scalars . .. external functions .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. where tauq and taup are complex Scalars, and v and u are comple v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in where tauq and taup are complex Scalars, and v and u are comple v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in where tauq and taup are complex Scalars, and v and u are comple .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. external subroutines .. .. .. local Scalars . .. external subroutines .. if incx = 1, and locr(ix) otherwise. this array contains the householder Scalars related to the householder vectors if incv = m_v, and locc(jv+k-1) otherwise. this array contains the householder Scalars related to the householde .. .. local Scalars . .. external subroutines .. .. .. local Scalars . .. external subroutines .. if incv = m_v, and locc(jv+k-1) otherwise. this array contains the householder Scalars related to the householde .. local Scalars . .. external functions .. .. .. local Scalars . .. external functions .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. local arrays .. .. local Scalars . .. local Scalars . .. .. local Scalars . .. local arrays .. .. local Scalars . .. .. local Scalars . .. local arrays .. .. local Scalars . .. .. local Scalars . .. local arrays .. .. .. local Scalars . .. external functions .. .. local Scalars . .. .. local Scalars . .. local arrays .. .. local Scalars . .. local Scalars . .. .. local Scalars . .. local arrays .. .. local Scalars . .. local Scalars . .. local Scalars . |
| scale scale normalize and scale the righthand side vector pb scale submatrix in rows and columns l to len m-by-n distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja:ja+n-1) and reduce its condition number. r returns the row scale factors and each row and column of the distributed matrix b with elements on exit, if equed .ne. 'n', a(ia:ia+n-1,ja:ja+n-1) is scale equed = 'r': a(ia:ia+n-1,ja:ja+n-1) := scale (global output) rea compensate for the scaling performed in this routine. scale (global output) rea compensate for the scaling performed in this routine. r (local input) real array, dimension locr(m_a) the row scale factors for sub( a ). r is aligned with th column. r is tied to the distributed matrix a. sr (local input) real array, dimension locr(m_a) the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligne process column. sr is tied to the distributed matrix a. ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). scale the column norms by tscal if the maximum element in cnorm i sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number (with respect to the two-norm). sr and sc contain the scale buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones on dimension (lld_a) the scale factors for a distributed across process rows fact = 'f'; otherwise, sr is an output variable. m-by-n distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja:ja+n-1) and reduce its condition number. r returns the row scale factors and each row and column of the distributed matrix b with elements on exit, if equed .ne. 'n', a(ia:ia+n-1,ja:ja+n-1) is scale equed = 'r': a(ia:ia+n-1,ja:ja+n-1) := r (local input) double precision array, dimension locr(m_a) the row scale factors for sub( a ). r is aligned with th column. r is tied to the distributed matrix a. sr (local input) double precision array, dimension locr(m_a) the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligne process column. sr is tied to the distributed matrix a. ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ). sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number (with respect to the two-norm). sr and sc contain the scale buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones on dimension (lld_a) the scale factors for a distributed across process rows fact = 'f'; otherwise, sr is an output variable. scale (global output) double precisio compensate for the scaling performed in this routine. scale (global output) double precisio compensate for the scaling performed in this routine. m-by-n distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja:ja+n-1) and reduce its condition number. r returns the row scale factors and each row and column of the distributed matrix b with elements on exit, if equed .ne. 'n', a(ia:ia+n-1,ja:ja+n-1) is scale equed = 'r': a(ia:ia+n-1,ja:ja+n-1) := r (local input) real array, dimension locr(m_a) the row scale factors for sub( a ). r is aligned with th column. r is tied to the distributed matrix a. sr (local input) real array, dimension locr(m_a) the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligne process column. sr is tied to the distributed matrix a. ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ). sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number (with respect to the two-norm). sr and sc contain the scale buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones on dimension (lld_a) the scale factors for a distributed across process rows fact = 'f'; otherwise, sr is an output variable. scale (global output) rea compensate for the scaling performed in this routine. scale (global output) rea compensate for the scaling performed in this routine. m-by-n distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja:ja+n-1) and reduce its condition number. r returns the row scale factors and each row and column of the distributed matrix b with elements on exit, if equed .ne. 'n', a(ia:ia+n-1,ja:ja+n-1) is scale equed = 'r': a(ia:ia+n-1,ja:ja+n-1) := scale (global output) double precisio compensate for the scaling performed in this routine. scale (global output) double precisio compensate for the scaling performed in this routine. r (local input) double precision array, dimension locr(m_a) the row scale factors for sub( a ). r is aligned with th column. r is tied to the distributed matrix a. sr (local input) double precision array, dimension locr(m_a) the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligne process column. sr is tied to the distributed matrix a. ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). scale the column norms by tscal if the maximum element in cnorm i sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number (with respect to the two-norm). sr and sc contain the scale buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones on dimension (lld_a) the scale factors for a distributed across process rows fact = 'f'; otherwise, sr is an output variable. normalize and scale the righthand side vector pb scale submatrix in rows and columns l to len |
| scaled scaled amax is very close to overflow or very close to underflow, the matrix should be scaled info (global output) integer on exit, if equed .ne. 'n', a(ia:ia+n-1,ja:ja+n-1) is scaled equed = 'r': a(ia:ia+n-1,ja:ja+n-1) := scale (global output) real amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is scale (global output) real amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is perform the global scaled su x (input) complex the vector for which a scaled sum of squares is computed (with respect to the two-norm). sr and sc contain the scale factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri the diagonal. this choice of sr and sc puts the condition number amax is very close to overflow or very close to underflow, the matrix should be scaled info (global output) integer on exit, if equed .ne. 'n', a(ia:ia+n-1,ja:ja+n-1) is scaled equed = 'r': a(ia:ia+n-1,ja:ja+n-1) := entries are d(2),d(4),...,d(2*n-2). to avoid overflow, the matrix must be scaled so that its largest entry is no greate and for greatest accuracy, it should not be much smaller perform the global scaled su entries are d(2),d(4),...,d(2*n-2). to avoid overflow, the matrix must be scaled so that its largest entry is no greate and for greatest accuracy, it should not be much smaller x (input) double precision the vector for which a scaled sum of squares is computed (with respect to the two-norm). sr and sc contain the scale factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri the diagonal. this choice of sr and sc puts the condition number the n diagonal elements of the tridiagonal matrix t. to avoid overflow, the matrix must be scaled so that its larges in absolute value, and for greatest accuracy, it should not scale (global output) double precision amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is scale (global output) double precision amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is amax is very close to overflow or very close to underflow, the matrix should be scaled info (global output) integer on exit, if equed .ne. 'n', a(ia:ia+n-1,ja:ja+n-1) is scaled equed = 'r': a(ia:ia+n-1,ja:ja+n-1) := entries are d(2),d(4),...,d(2*n-2). to avoid overflow, the matrix must be scaled so that its largest entry is no greate and for greatest accuracy, it should not be much smaller perform the global scaled su entries are d(2),d(4),...,d(2*n-2). to avoid overflow, the matrix must be scaled so that its largest entry is no greate and for greatest accuracy, it should not be much smaller x (input) real the vector for which a scaled sum of squares is computed (with respect to the two-norm). sr and sc contain the scale factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri the diagonal. this choice of sr and sc puts the condition number the n diagonal elements of the tridiagonal matrix t. to avoid overflow, the matrix must be scaled so that its larges in absolute value, and for greatest accuracy, it should not scale (global output) real amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is scale (global output) real amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is amax is very close to overflow or very close to underflow, the matrix should be scaled info (global output) integer on exit, if equed .ne. 'n', a(ia:ia+n-1,ja:ja+n-1) is scaled equed = 'r': a(ia:ia+n-1,ja:ja+n-1) := scale (global output) double precision amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is scale (global output) double precision amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is perform the global scaled su x (input) complex*16 the vector for which a scaled sum of squares is computed (with respect to the two-norm). sr and sc contain the scale factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri the diagonal. this choice of sr and sc puts the condition number |
| scaling scaling pcgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c 1. if fact = 'e', real scaling factors are computed to equilibrat trans = 'n': diag(r)*a*diag(c) *inv(diag(c))*x = diag(r)*b amount by which the eigenvalues should be scaled to compensate for the scaling performed in this routine returned here to allow for future enhancement. amount by which the eigenvalues should be scaled to compensate for the scaling performed in this routine returned here to allow for future enhancement. pclaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scaling pclaqsy equilibrates a symmetric distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in th on entry, the value scale in the equation above. on exit, scale is overwritten with scl , the scaling facto use a level 1 pblas solve, scaling intermediate results pcpoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number 1. if fact = 'e', real scaling factors are computed to equilibrat diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b the algorithm used in this program is basically backward (forward) substitution. it is the hope that scaling would be used to make th been implemented in pclattrs which is called by this routine to solve pdgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c 1. if fact = 'e', real scaling factors are computed to equilibrat trans = 'n': diag(r)*a*diag(c) *inv(diag(c))*x = diag(r)*b pdlaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scaling pdlaqsy equilibrates a symmetric distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in th on entry, the value scale in the equation above. on exit, scale is overwritten with scl , the scaling facto pdpoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number 1. if fact = 'e', real scaling factors are computed to equilibrat diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b amount by which the eigenvalues should be scaled to compensate for the scaling performed in this routine returned here to allow for future enhancement. amount by which the eigenvalues should be scaled to compensate for the scaling performed in this routine returned here to allow for future enhancement. psgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c 1. if fact = 'e', real scaling factors are computed to equilibrat trans = 'n': diag(r)*a*diag(c) *inv(diag(c))*x = diag(r)*b pslaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scaling pslaqsy equilibrates a symmetric distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in th on entry, the value scale in the equation above. on exit, scale is overwritten with scl , the scaling facto pspoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number 1. if fact = 'e', real scaling factors are computed to equilibrat diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b amount by which the eigenvalues should be scaled to compensate for the scaling performed in this routine returned here to allow for future enhancement. amount by which the eigenvalues should be scaled to compensate for the scaling performed in this routine returned here to allow for future enhancement. pzgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c 1. if fact = 'e', real scaling factors are computed to equilibrat trans = 'n': diag(r)*a*diag(c) *inv(diag(c))*x = diag(r)*b amount by which the eigenvalues should be scaled to compensate for the scaling performed in this routine returned here to allow for future enhancement. amount by which the eigenvalues should be scaled to compensate for the scaling performed in this routine returned here to allow for future enhancement. pzlaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scaling pzlaqsy equilibrates a symmetric distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in th on entry, the value scale in the equation above. on exit, scale is overwritten with scl , the scaling facto use a level 1 pblas solve, scaling intermediate results pzpoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number 1. if fact = 'e', real scaling factors are computed to equilibrat diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b the algorithm used in this program is basically backward (forward) substitution. it is the hope that scaling would be used to make th been implemented in pzlattrs which is called by this routine to solve |
| scalings scalings pcgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c pcpoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number pdgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c pdpoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number psgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c pspoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number pzgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c pzpoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number |
| scan scan on entry, the hessenberg matrix whose tridiagonal part is being scanned on entry, the hessenberg matrix whose tridiagonal part is being scanned on entry, the hessenberg matrix whose tridiagonal part is being scanned on entry, the hessenberg matrix whose tridiagonal part is being scanned |
| scanned scanned on entry, the hessenberg matrix whose tridiagonal part is being scanned on entry, the hessenberg matrix whose tridiagonal part is being scanned on entry, the hessenberg matrix whose tridiagonal part is being scanned on entry, the hessenberg matrix whose tridiagonal part is being scanned on entry, the hessenberg matrix whose tridiagonal part is being scanned on entry, the hessenberg matrix whose tridiagonal part is being scanned on entry, the hessenberg matrix whose tridiagonal part is being scanned on entry, the hessenberg matrix whose tridiagonal part is being scanned |
| scheme scheme the band storage scheme is illustrated by the following example, whe the band storage scheme is illustrated by the following example, whe the band storage scheme is illustrated by the following example, whe the band storage scheme is illustrated by the following example, whe |
| Schmidt Schmidt reorthogonalize by modified gram-Schmidt if eigenvalues ar reorthogonalize by modified gram-Schmidt if eigenvalues ar |
| schur schur clanv2 computes the schur factorization of a complex 2-by- s (local input/output) double precision array, dimension lds on entry, a matrix already in schur form the eigenvalues. the resulting matrix is no longer the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already products q*x and/or q*y, where q is an input unitary matrix. if t was obtained from the schur factorization of a right or left eigenvectors of a. the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already products q*x and/or q*y, where q is an input unitary matrix. if t was obtained from the schur factorization of a right or left eigenvectors of a. s (local input/output) real array, dimension lds on entry, a matrix already in schur form the eigenvalues. the resulting matrix is no longer zlanv2 computes the schur factorization of a complex 2-by- |
| Sci Sci on distributed memory architectures", siam j. Sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps on distributed memory architectures", siam j. Sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps on distributed memory architectures", siam j. Sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps on distributed memory architectures", siam j. Sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps on distributed memory architectures", siam j. Sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps on distributed memory architectures", siam j. Sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps |
| Science Science see w. kahan "accurate eigenvalues of a symmetric tridiagonal matrix", report cs41, computer Science dept., stanfor see w. kahan "accurate eigenvalues of a symmetric tridiagonal matrix", report cs41, computer Science dept., stanfor |
| Scientific Scientific based on code written by : peter arbenz, eth zurich, 1996. last modified by: peter arbenz, institute of Scientific computing based on code written by : peter arbenz, eth zurich, 1996. last modified by: peter arbenz, institute of Scientific computing |
| scl scl pclassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, pdlassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, pslassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, pzlassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, |
| SCOND SCOND SCOND (global input) rea largest sr(i) (respectively sc(j)), with ia <= i <= ia+n-1 SCOND (global output) rea (or sc(j)) to the largest sr(i) (or sc(j)), with SCOND (global input) double precisio largest sr(i) (respectively sc(j)), with ia <= i <= ia+n-1 SCOND (global output) double precisio (or sc(j)) to the largest sr(i) (or sc(j)), with SCOND (global input) rea largest sr(i) (respectively sc(j)), with ia <= i <= ia+n-1 SCOND (global output) rea (or sc(j)) to the largest sr(i) (or sc(j)), with SCOND (global input) double precisio largest sr(i) (respectively sc(j)), with ia <= i <= ia+n-1 SCOND (global output) double precisio (or sc(j)) to the largest sr(i) (or sc(j)), with |
| scope scope alpha (local output) complex on exit, alpha is computed in the process scope having th the result are only available in the scope of sub( x ), i.e i only available in this process row of the grid. similarly if sub( x ) when the result of a vector-oriented pblas call is a scalar, it will be made available only within the scope which owns the vector(s then, the processes which receive the answer will be (note that if alpha (local output) double precision on exit, alpha is computed in the process scope having th the result are only available in the scope of sub( x ), i.e i only available in this process row of the grid. similarly if sub( x ) when the result of a vector-oriented pblas call is a scalar, it will be made available only within the scope which owns the vector(s then, the processes which receive the answer will be (note that if when the result of a vector-oriented pblas call is a scalar, it will be made available only within the scope which owns the vector(s then, the processes which receive the answer will be (note that if alpha (local output) real on exit, alpha is computed in the process scope having th the result are only available in the scope of sub( x ), i.e i only available in this process row of the grid. similarly if sub( x ) alpha (local output) complex*16 on exit, alpha is computed in the process scope having th the result are only available in the scope of sub( x ), i.e i only available in this process row of the grid. similarly if sub( x ) when the result of a vector-oriented pblas call is a scalar, it will be made available only within the scope which owns the vector(s then, the processes which receive the answer will be (note that if |
| Sdbtrf Sdbtrf Sdbtrf computes an lu factorization of a real m-by-n band matrix |
| SDTTRF SDTTRF SDTTRF computes an lu factorization of a complex tridiagonal matrix with factors of the tridiagonal matrix a from the lu factorization computed by SDTTRF arguments |
| SDTTRSV SDTTRSV SDTTRSV solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, |
| Search Search by pchetrd to keep the interface simple. these restrictions are documented below. (Search for "restrictions". notes by pdsytrd to keep the interface simple. these restrictions are documented below. (Search for "restrictions". notes by pssytrd to keep the interface simple. these restrictions are documented below. (Search for "restrictions". notes by pzhetrd to keep the interface simple. these restrictions are documented below. (Search for "restrictions". notes |
| searched searched vl (global input) real if range='v', the lower bound of the interval to be searched vl (global input) real if range='v', the lower bound of the interval to be searched vl (global input) double precision if range='v', the lower bound of the interval to be searched returned. not referenced if range='a' or 'i'. vl (global input) double precision if range='v', the lower bound of the interval to be searched vl (global input) double precision if range='v', the lower bound of the interval to be searched vl (global input) real if range='v', the lower bound of the interval to be searched returned. not referenced if range='a' or 'i'. vl (global input) real if range='v', the lower bound of the interval to be searched vl (global input) real if range='v', the lower bound of the interval to be searched vl (global input) double precision if range='v', the lower bound of the interval to be searched vl (global input) double precision if range='v', the lower bound of the interval to be searched |
| searches searches needs, they will be sent and received. then the next major loop passes over the data and searches for two consecutiv needs, they will be sent and received. then the next major loop passes over the data and searches for two consecutiv needs, they will be sent and received. then the next major loop passes over the data and searches for two consecutiv needs, they will be sent and received. then the next major loop passes over the data and searches for two consecutiv |
| second second v2 (local input) complex array of dimension 2. the second maximum absolute value element and its globa z (global input/output) complex array, (ldz,*) on entry, the second matrix to receive column reflections z (global input/output) double precision array, (ldz,*) on entry, the second matrix to receive column reflections is actually stored in one buffer buf where buf(istr1+1) starts the first buffer, buf(istr2+1) starts the second, etc.. afte needs, they will be sent and received. then the next major first submatrix from the top, 2 for those belonging to the second submatrix, etc. (the output array ibloc is actually stored in one buffer buf where buf(istr1+1) starts the first buffer, buf(istr2+1) starts the second, etc.. afte needs, they will be sent and received. then the next major the second stage consists of calculating the update equation via the routine slaed4 (as called by pdlaed3). row of the first sub-eigenvector matrix and the first row of the second sub-eigenvector matrix) process. row of the first sub-eigenvector matrix and the first row of the second sub-eigenvector matrix) process. the first submatrix consists of rows/columns 1 to isplit(1), the second of rows/columns isplit(1)+1 through isplit(2) isplit(nsplit-1)+1 through isplit(nsplit)=n. first submatrix from the top, 2 for those belonging to the second submatrix, etc. (the output array ibloc 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 is actually stored in one buffer buf where buf(istr1+1) starts the first buffer, buf(istr2+1) starts the second, etc.. afte needs, they will be sent and received. then the next major the second stage consists of calculating the update equation via the routine slaed4 (as called by pslaed3). row of the first sub-eigenvector matrix and the first row of the second sub-eigenvector matrix) process. row of the first sub-eigenvector matrix and the first row of the second sub-eigenvector matrix) process. the first submatrix consists of rows/columns 1 to isplit(1), the second of rows/columns isplit(1)+1 through isplit(2) isplit(nsplit-1)+1 through isplit(nsplit)=n. first submatrix from the top, 2 for those belonging to the second submatrix, etc. (the output array ibloc is actually stored in one buffer buf where buf(istr1+1) starts the first buffer, buf(istr2+1) starts the second, etc.. afte needs, they will be sent and received. then the next major first submatrix from the top, 2 for those belonging to the second submatrix, etc. (the output array ibloc z (global input/output) real array, (ldz,*) on entry, the second matrix to receive column reflections v2 (local input) complex*16 array of dimension 2. the second maximum absolute value element and its globa z (global input/output) complex*16 array, (ldz,*) on entry, the second matrix to receive column reflections |
| section section receive previously transmitted matrix section, which form the "spike" fillin. receive previously transmitted matrix section, which form the "spike" fillin. receive previously transmitted matrix section, which form the "spike" fillin. receive previously transmitted matrix section, which form the "spike" fillin. receive previously transmitted matrix section, which form the "spike" fillin. receive previously transmitted matrix section, which form the "spike" fillin. receive previously transmitted matrix section, which form the "spike" fillin. receive previously transmitted matrix section, which form the "spike" fillin. receive previously transmitted matrix section, which form the "spike" fillin. receive previously transmitted matrix section, which form the "spike" fillin. receive previously transmitted matrix section, which form the "spike" fillin. receive previously transmitted matrix section, which form the "spike" fillin. |
| sections sections gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste gather up local sections of reduced syste |
| secular secular the z vector. for each such occurence the dimension of the secular equation problem is reduced by one. this stage i eigenvalues are close together or if there is a tiny entry in the z vector. for each such occurrence the order of the related secular pdlaed3 finds the roots of the secular equation, as defined by th appropriate calls to slaed4 the z vector. for each such occurence the dimension of the secular equation problem is reduced by one. this stage i eigenvalues are close together or if there is a tiny entry in the z vector. for each such occurrence the order of the related secular pslaed3 finds the roots of the secular equation, as defined by th appropriate calls to slaed4 |
| sed sed array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute array a. mb_a (global) desca( mb_ ) the blocking factor used to distribut nb_a (global) desca( nb_ ) the blocking factor used to distribute |
| See See factorization are stored in rows kl+ku+2 to 2*kl+ku+1. See below for further details ldab (input) integer determine the effect of starting the double-shift qr iteration at row m, and See if this would make h(m,m-1 clamsh sends multiple shifts through a small (single node) matrix to See how consecutive small subdiagonal elements are modified b that can be sent through. factor u or l from the factorization computed by cpttrf (See uplo) b (input/output) complex array, dimension (ldb,nrhs) factorization are stored in rows kl+ku+2 to 2*kl+ku+1. See below for further details ldab (input) integer dlamsh sends multiple shifts through a small (single node) matrix to See how consecutive small subdiagonal elements are modified b that can be sent through. factor u or l from the factorization computed by dpttrf (See uplo) b (input/output) complex array, dimension (ldb,nrhs) See pcdbtrf and pcdbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. See pcdttrf and pcdttrs for details ===================================================================== contains information of mapping of a to memory. please See notes below for full description and options b (local input/local output) complex pointer into See pcgbtrf and pcgbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. with the array taup, represent the orthogonal matrix p as a product of elementary reflectors. See further details ia (global input) integer with the array taup, represent the orthogonal matrix p as a product of elementary reflectors. See further details ia (global input) integer rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+jlo-2 and ja+jhi:ja+n-1. See further details. if n > 0 rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+ilo-2 and ja+ihi:ja+n-1. See further details. if n > 0 sent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer sent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer array tau, represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer array tau, represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer sent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer tau, represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer tau, represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u of the equili- brated matrix a(ia:ia+n-1,ja:ja+n-1) (See the description o matrix). represent the unitary matrix q as a product of min(n,m) elementary reflectors (See further details) ia (global input) integer taua, represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer lwork (local input) integer See below for definitions of variables used to define lwork lwork >= max( nb*( np0+1 ), 3 ) +3*n siam j. sci. comput., 6:20 (1999), pp. 2223--2236. (See also lapack working note 132 See "computing small singular values of bidiagonal matrice kahan, lapack working note #3. See "computing small singular values of bidiagonal matrice kahan, lapack working note #3. represent the unitary matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the unitary matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the unitary matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the unitary matrix q as a product of elementary reflectors. See further details ia (global input) integer a product of elementary reflectors. See further details ia (global input) integer pclaconsb looks for two consecutive small subdiagonal elements by Seeing the effect of starting a double shift qr iteratio subdiagonal negligible. if we are starting in the middle because of consecutive small subdiagonal elements, we need to See how many bulges w subdiagonal property. reflectors. the other columns of a(ia:ia+n-1,ja:ja+n-k) are unchanged. See further details ia (global input) integer containing on entry the m-by-n matrix sub( a ). on exit, the equilibrated distributed matrix. See equed for th vectors v representing the householder transformation. See further details if storev = 'c' and side = 'r', lld_v >= max(1,locr(iv+n-1)); specifies how the vectors which define the elementary reflectors are stored (See also further details) = 'r': rowwise specifies how the vectors which define the elementary reflectors are stored (See also further details) = 'r': rowwise represent the unitary matrix q as a product of elementary reflectors; See further details ia (global input) integer compute a bound on the computed solution vector to See if th See pcpbtrf and pcpbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. factorization a = u**t*u or a = l*l**t of the equilibrated matrix a (See the description of a for the form of th See pcpttrf and pcpttrs for details ===================================================================== contains information of mapping of a to memory. please See notes below for full description and options b (local input/local output) complex pointer into orfac*||t|| of each other are to be orthogonalized. however, if the workspace is insufficient (See lwork), thi orthogonalized can be stored in one process. See pddbtrf and pddbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. See pddttrf and pddttrs for details ===================================================================== contains information of mapping of a to memory. please See notes below for full description and options b (local input/local output) double precision pointer into See pdgbtrf and pdgbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. with the array taup, represent the orthogonal matrix p as a product of elementary reflectors. See further details ia (global input) integer with the array taup, represent the orthogonal matrix p as a product of elementary reflectors. See further details ia (global input) integer rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+jlo-2 and ja+jhi:ja+n-1. See further details. if n > 0 rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+ilo-2 and ja+ihi:ja+n-1. See further details. if n > 0 sent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer sent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer array tau, represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer array tau, represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer sent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer tau, represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer tau, represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u of the equili- brated matrix a(ia:ia+n-1,ja:ja+n-1) (See the description o matrix). represent the orthogonal matrix q as a product of min(n,m) elementary reflectors (See further details) ia (global input) integer taua, represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer a product of elementary reflectors. See further details ia (global input) integer pdlaconsb looks for two consecutive small subdiagonal elements by Seeing the effect of starting a double shift qr iteratio subdiagonal negligible. without overflow. See pdlapdct for the "paranoid" implementation of the stur the counts at the endpoints are identical to the counts specified by nval ( See nval ) then the interval i reflectors. the other columns of a(ia:ia+n-1,ja:ja+n-k) are unchanged. See further details ia (global input) integer containing on entry the m-by-n matrix sub( a ). on exit, the equilibrated distributed matrix. See equed for th vectors v representing the householder transformation. See further details if storev = 'c' and side = 'r', lld_v >= max(1,locr(iv+n-1)); specifies how the vectors which define the elementary reflectors are stored (See also further details) = 'r': rowwise specifies how the vectors which define the elementary reflectors are stored (See also further details) = 'r': rowwise represent the orthogonal matrix q as a product of elementary reflectors; See further details ia (global input) integer See pdpbtrf and pdpbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. factorization a = u**t*u or a = l*l**t of the equilibrated matrix a (See the description of a for the form of th See pdpttrf and pdpttrs for details ===================================================================== contains information of mapping of a to memory. please See notes below for full description and options b (local input/local output) double precision pointer into See w. kahan "accurate eigenvalues of a symmetric tridiagona university, july 21, 1966. it could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See dlaed3 for details arguments orfac*||t|| of each other are to be orthogonalized. however, if the workspace is insufficient (See lwork), thi orthogonalized can be stored in one process. lwork (local input) integer See below for definitions of variables used to define lwork lwork >= 5*n + sizesytrd + 1 siam j. sci. comput., 6:20 (1999), pp. 2223--2236. (See also lapack working note 132 See "computing small singular values of bidiagonal matrice kahan, lapack working note #3. See "computing small singular values of bidiagonal matrice kahan, lapack working note #3. represent the orthogonal matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the orthogonal matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the orthogonal matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the unitary matrix q as a product of elementary reflectors. See further details ia (global input) integer tailored eigen-routines to choose problem-dependent parameters for the local environment. See ispe See psdbtrf and psdbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. See psdttrf and psdttrs for details ===================================================================== contains information of mapping of a to memory. please See notes below for full description and options b (local input/local output) real pointer into See psgbtrf and psgbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. with the array taup, represent the orthogonal matrix p as a product of elementary reflectors. See further details ia (global input) integer with the array taup, represent the orthogonal matrix p as a product of elementary reflectors. See further details ia (global input) integer rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+jlo-2 and ja+jhi:ja+n-1. See further details. if n > 0 rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+ilo-2 and ja+ihi:ja+n-1. See further details. if n > 0 sent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer sent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer array tau, represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer array tau, represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer sent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer tau, represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer tau, represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u of the equili- brated matrix a(ia:ia+n-1,ja:ja+n-1) (See the description o matrix). represent the orthogonal matrix q as a product of min(n,m) elementary reflectors (See further details) ia (global input) integer taua, represent the orthogonal matrix q as a product of elementary reflectors (See further details) ia (global input) integer a product of elementary reflectors. See further details ia (global input) integer pslaconsb looks for two consecutive small subdiagonal elements by Seeing the effect of starting a double shift qr iteratio subdiagonal negligible. without overflow. See pslapdct for the "paranoid" implementation of the stur the counts at the endpoints are identical to the counts specified by nval ( See nval ) then the interval i reflectors. the other columns of a(ia:ia+n-1,ja:ja+n-k) are unchanged. See further details ia (global input) integer containing on entry the m-by-n matrix sub( a ). on exit, the equilibrated distributed matrix. See equed for th vectors v representing the householder transformation. See further details if storev = 'c' and side = 'r', lld_v >= max(1,locr(iv+n-1)); specifies how the vectors which define the elementary reflectors are stored (See also further details) = 'r': rowwise specifies how the vectors which define the elementary reflectors are stored (See also further details) = 'r': rowwise represent the orthogonal matrix q as a product of elementary reflectors; See further details ia (global input) integer See pspbtrf and pspbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. factorization a = u**t*u or a = l*l**t of the equilibrated matrix a (See the description of a for the form of th See pspttrf and pspttrs for details ===================================================================== contains information of mapping of a to memory. please See notes below for full description and options b (local input/local output) real pointer into See w. kahan "accurate eigenvalues of a symmetric tridiagona university, july 21, 1966. it could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See slaed3 for details arguments orfac*||t|| of each other are to be orthogonalized. however, if the workspace is insufficient (See lwork), thi orthogonalized can be stored in one process. lwork (local input) integer See below for definitions of variables used to define lwork lwork >= 5*n + sizesytrd + 1 siam j. sci. comput., 6:20 (1999), pp. 2223--2236. (See also lapack working note 132 See "computing small singular values of bidiagonal matrice kahan, lapack working note #3. See "computing small singular values of bidiagonal matrice kahan, lapack working note #3. represent the orthogonal matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the orthogonal matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the orthogonal matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the unitary matrix q as a product of elementary reflectors. See further details ia (global input) integer See pzdbtrf and pzdbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. See pzdttrf and pzdttrs for details ===================================================================== contains information of mapping of a to memory. please See notes below for full description and options b (local input/local output) complex*16 pointer into See pzgbtrf and pzgbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. with the array taup, represent the orthogonal matrix p as a product of elementary reflectors. See further details ia (global input) integer with the array taup, represent the orthogonal matrix p as a product of elementary reflectors. See further details ia (global input) integer rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+jlo-2 and ja+jhi:ja+n-1. See further details. if n > 0 rows ia:ia+ilo-2 and ia+ihi:ia+n-1 and columns ja:ja+ilo-2 and ja+ihi:ja+n-1. See further details. if n > 0 sent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer sent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer array tau, represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer array tau, represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer sent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer tau, represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer tau, represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u of the equili- brated matrix a(ia:ia+n-1,ja:ja+n-1) (See the description o matrix). represent the unitary matrix q as a product of min(n,m) elementary reflectors (See further details) ia (global input) integer taua, represent the unitary matrix q as a product of elementary reflectors (See further details) ia (global input) integer lwork (local input) integer See below for definitions of variables used to define lwork lwork >= max( nb*( np0+1 ), 3 ) +3*n siam j. sci. comput., 6:20 (1999), pp. 2223--2236. (See also lapack working note 132 See "computing small singular values of bidiagonal matrice kahan, lapack working note #3. See "computing small singular values of bidiagonal matrice kahan, lapack working note #3. represent the unitary matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the unitary matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the unitary matrix q as a product of elementary reflectors. See further details ia (global input) integer represent the unitary matrix q as a product of elementary reflectors. See further details ia (global input) integer a product of elementary reflectors. See further details ia (global input) integer pzlaconsb looks for two consecutive small subdiagonal elements by Seeing the effect of starting a double shift qr iteratio subdiagonal negligible. if we are starting in the middle because of consecutive small subdiagonal elements, we need to See how many bulges w subdiagonal property. reflectors. the other columns of a(ia:ia+n-1,ja:ja+n-k) are unchanged. See further details ia (global input) integer containing on entry the m-by-n matrix sub( a ). on exit, the equilibrated distributed matrix. See equed for th vectors v representing the householder transformation. See further details if storev = 'c' and side = 'r', lld_v >= max(1,locr(iv+n-1)); specifies how the vectors which define the elementary reflectors are stored (See also further details) = 'r': rowwise specifies how the vectors which define the elementary reflectors are stored (See also further details) = 'r': rowwise represent the unitary matrix q as a product of elementary reflectors; See further details ia (global input) integer compute a bound on the computed solution vector to See if th See pzpbtrf and pzpbtrs for details ===================================================================== this local portion is stored in the packed banded format used in lapack. please See the notes below and th distributed matrices. factorization a = u**t*u or a = l*l**t of the equilibrated matrix a (See the description of a for the form of th See pzpttrf and pzpttrs for details ===================================================================== contains information of mapping of a to memory. please See notes below for full description and options b (local input/local output) complex*16 pointer into orfac*||t|| of each other are to be orthogonalized. however, if the workspace is insufficient (See lwork), thi orthogonalized can be stored in one process. factorization are stored in rows kl+ku+2 to 2*kl+ku+1. See below for further details ldab (input) integer slamsh sends multiple shifts through a small (single node) matrix to See how consecutive small subdiagonal elements are modified b that can be sent through. factor u or l from the factorization computed by spttrf (See uplo) b (input/output) complex array, dimension (ldb,nrhs) factorization are stored in rows kl+ku+2 to 2*kl+ku+1. See below for further details ldab (input) integer determine the effect of starting the double-shift qr iteration at row m, and See if this would make h(m,m-1 zlamsh sends multiple shifts through a small (single node) matrix to See how consecutive small subdiagonal elements are modified b that can be sent through. factor u or l from the factorization computed by zpttrf (See uplo) b (input/output) complex array, dimension (ldb,nrhs) |
| seed seed initialize seed for random number generator dlarnv initialize seed for random number generator slarnv |
| seeing seeing pclaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. pdlaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. pslaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. pzlaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. |
| seen seen because vectors may be seen as particular matrices, a distribute because vectors may be seen as particular matrices, a distribute because vectors may be seen as particular matrices, a distribute because vectors may be seen as particular matrices, a distribute |
| SELECT SELECT supplied in vr and/or vl; = 's': compute SELECTed right and/or left eigenvectors supplied in vr and/or vl; = 's': compute SELECTed right and/or left eigenvectors |
| selected selected pcheev computes selected eigenvalues and, optionally, eigenvector of scalapack routines. pcheevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by w (global output) real array, dimension (n) on normal exit, the first m entries contain the selected supplied in vr and/or vl; = 's': compute selected right and/or left eigenvectors w (global output) double precision array, dimension (n) on normal exit, the first m entries contain the selected pdsyevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by w (global output) double precision array, dimension (n) on normal exit, the first m entries contain the selected w (global output) real array, dimension (n) on normal exit, the first m entries contain the selected pssyevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by w (global output) real array, dimension (n) on normal exit, the first m entries contain the selected pzheev computes selected eigenvalues and, optionally, eigenvector of scalapack routines. pzheevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by w (global output) double precision array, dimension (n) on normal exit, the first m entries contain the selected supplied in vr and/or vl; = 's': compute selected right and/or left eigenvectors |
| send send clamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges dlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side transfer triangle b_i of local matrix to next processor for fillin. overlap the send with the factorization of a_i 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 square blocks. there are 5 buffers that each node stores these values: a buffer to send diagonally down and right, a buffe up and left and a buffer to send right. each of these buffers if rev<>0, then ii is the source row index for the node(s) sending the replicated b jj (global input) integer subdiagonal elements, we need to see how many bulges we can send through without breaking the consecutive smal although all processes call pcgemr2d, only the processes that own the first column of a send data and only processes that own th spread the data down. send v and tau to the process column icco send v and tau to the process column icco send v and tau to the process column iccol send v and tau to the process column iccol its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side transfer triangle b_i of local matrix to next processor for fillin. overlap the send with the factorization of a_i square blocks. there are 5 buffers that each node stores these values: a buffer to send diagonally down and right, a buffe up and left and a buffer to send right. each of these buffers if rev<>0, then ii is the source row index for the node(s) sending the replicated b jj (global input) integer although all processes call pdgemr2d, only the processes that own the first column of a send data and only processes that own th spread the data down. send v and tau to the process column icco send v and tau to the process column iccol its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side 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 its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side transfer triangle b_i of local matrix to next processor for fillin. overlap the send with the factorization of a_i square blocks. there are 5 buffers that each node stores these values: a buffer to send diagonally down and right, a buffe up and left and a buffer to send right. each of these buffers if rev<>0, then ii is the source row index for the node(s) sending the replicated b jj (global input) integer although all processes call psgemr2d, only the processes that own the first column of a send data and only processes that own th spread the data down. send v and tau to the process column icco send v and tau to the process column iccol its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side 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 its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side transfer triangle b_i of local matrix to next processor for fillin. overlap the send with the factorization of a_i 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 square blocks. there are 5 buffers that each node stores these values: a buffer to send diagonally down and right, a buffe up and left and a buffer to send right. each of these buffers if rev<>0, then ii is the source row index for the node(s) sending the replicated b jj (global input) integer subdiagonal elements, we need to see how many bulges we can send through without breaking the consecutive smal although all processes call pzgemr2d, only the processes that own the first column of a send data and only processes that own th spread the data down. send v and tau to the process column icco send v and tau to the process column icco send v and tau to the process column iccol send v and tau to the process column iccol its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side its main (odd) block a_i. overlap the send with the factorization of a_i send modifications to prior processor's right hand side slamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges zlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges |
| sending sending the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start if rev<>0, then ii is the source row index for the node(s) sending the replicated b jj (global input) integer efficient parallelism: loop over all the bulges, just sending the data ou loop over all the bulges, just sending the data back. the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start if rev<>0, then ii is the source row index for the node(s) sending the replicated b jj (global input) integer the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start if rev<>0, then ii is the source row index for the node(s) sending the replicated b jj (global input) integer the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start if rev<>0, then ii is the source row index for the node(s) sending the replicated b jj (global input) integer efficient parallelism: loop over all the bulges, just sending the data ou loop over all the bulges, just sending the data back. the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start the distance for sending and receiving for each level start |
| sends sends clamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges dlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges slamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges zlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges |
| sent sent subsequent shifts in an effort to maximize the number of bulges that can be sent through (nbulge > 1) and the first shift is starting in the middle of an subsequent shifts in an effort to maximize the number of bulges that can be sent through (nbulge > 1) and the first shift is starting in the middle of an the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already ments below the first subdiagonal, with the array tau, repre- sent the unitary matrix q as a product of elementar ments below the first subdiagonal, 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 the elements above 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, repre- sent the unitary matrix q as a product of elementar the values are stored, if there are any values that a node needs, they will be sent and received. then the next majo small subdiagonals. ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already ments below the first subdiagonal, with the array tau, repre- sent the orthogonal matrix q as a product of elementar ments below the first subdiagonal, with the array tau, repre- sent the orthogonal matrix q as a product of elementar the elements above the diagonal, with the array tau, repre- sent the orthogonal matrix q as a product of elementar the elements above the diagonal, with the array tau, repre- sent the orthogonal matrix q as a product of elementar the elements below the diagonal, with the array tau, repre- sent the orthogonal matrix q as a product of elementar the values are stored, if there are any values that a node needs, they will be sent and received. then the next majo small subdiagonals. ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. work (local workspace) double precision dimension (lwork) used to hold the buffers sent from one process to anothe lwork (local input) integer size of work array work (local workspace) double precision dimension (lwork) used to hold the buffers sent from one process to anothe lwork (local input) integer size of work array the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already ments below the first subdiagonal, with the array tau, repre- sent the orthogonal matrix q as a product of elementar ments below the first subdiagonal, with the array tau, repre- sent the orthogonal matrix q as a product of elementar the elements above the diagonal, with the array tau, repre- sent the orthogonal matrix q as a product of elementar the elements above the diagonal, with the array tau, repre- sent the orthogonal matrix q as a product of elementar the elements below the diagonal, with the array tau, repre- sent the orthogonal matrix q as a product of elementar the values are stored, if there are any values that a node needs, they will be sent and received. then the next majo small subdiagonals. ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. work (local workspace) real dimension (lwork) used to hold the buffers sent from one process to anothe lwork (local input) integer size of work array work (local workspace) real dimension (lwork) used to hold the buffers sent from one process to anothe lwork (local input) integer size of work array the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already ments below the first subdiagonal, with the array tau, repre- sent the unitary matrix q as a product of elementar ments below the first subdiagonal, 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 the elements above 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, repre- sent the unitary matrix q as a product of elementar the values are stored, if there are any values that a node needs, they will be sent and received. then the next majo small subdiagonals. ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already the last processor does not participate in the factorization of the reduced system, having sent its e_i already initiate send of off-diag block(s) to overlap with next part. the last processor does not participate in the solution of the reduced system, having sent its contribution already subsequent shifts in an effort to maximize the number of bulges that can be sent through (nbulge > 1) and the first shift is starting in the middle of an subsequent shifts in an effort to maximize the number of bulges that can be sent through (nbulge > 1) and the first shift is starting in the middle of an |
| separate separate h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and h(m+2,m-1). since these elements may be on separate and has each node store whatever values of the 7 it has that h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and h(m+2,m-1). since these elements may be on separate and has each node store whatever values of the 7 it has that h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and h(m+2,m-1). since these elements may be on separate and has each node store whatever values of the 7 it has that h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and h(m+2,m-1). since these elements may be on separate and has each node store whatever values of the 7 it has that |
| separately separately 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. 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. 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. 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. 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. 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. handle first block separately handle first block of columns separately handle first block separately 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. handle first block of columns separately handle first block separately 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. handle first block of columns separately handle first block separately 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. handle first block separately handle first block of columns separately handle first block separately 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. 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. 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. 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. |
| separator separator size of separator blocks is maximum of bandwidth size of separator blocks is maximum of bandwidth size of separator blocks is maximum of bandwidth size of separator blocks is maximum of bandwidth size of separator blocks is maximum of bandwidth size of separator blocks is maximum of bandwidth size of separator blocks is maximum of bandwidth size of separator blocks is maximum of bandwidth |
| sequence sequence pcheev computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequence pcheevx computes selected eigenvalues and, optionally, eigenvectors of a complex hermitian matrix a by calling the recommended sequence specifying a range of values or a range of indices for the desired the minimum absolute of a "pivot" in the "paranoid" implementation of the sturm sequence loop. this must be a safe_min is at least the smallest number that can divide 1.0 pdlapdct counts the number of negative eigenvalues of (t - sigma i). this implementation of the sturm sequence loop has conditionals i floating point number. pdlapdct will be referred to as the "paranoid" pdsyev computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequence pdsyevd computes all the eigenvalues and eigenvectors of a real symmetric matrix a by calling the recommended sequence pdsyevx computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequence specifying a range of values or a range of indices for the desired the minimum absolute of a "pivot" in the "paranoid" implementation of the sturm sequence loop. this must be a safe_min is at least the smallest number that can divide 1.0 pslapdct counts the number of negative eigenvalues of (t - sigma i). this implementation of the sturm sequence loop has conditionals i floating point number. pslapdct will be referred to as the "paranoid" pssyev computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequence pssyevd computes all the eigenvalues and eigenvectors of a real symmetric matrix a by calling the recommended sequence pssyevx computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequence specifying a range of values or a range of indices for the desired pzheev computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequence pzheevx computes selected eigenvalues and, optionally, eigenvectors of a complex hermitian matrix a by calling the recommended sequence specifying a range of values or a range of indices for the desired |
| serial serial pchentrd is a prototype version of pchetrd which uses tailored codes (either the serial, chetrd, or the parallel code, pchettrd the serial version clacon has been contributed by nick higham march 16, 1988. the serial version was contributed to lapack by nick higham for us the serial version dlacon has been contributed by nick higham march 16, 1988. pdsyntrd is a prototype version of pdsytrd which uses tailored codes (either the serial, dsytrd, or the parallel code, pdsyttrd the serial version of this routine was originally contributed b the serial version of this routine was originally contributed b the serial version slacon has been contributed by nick higham march 16, 1988. pssyntrd is a prototype version of pssytrd which uses tailored codes (either the serial, ssytrd, or the parallel code, pssyttrd pzhentrd is a prototype version of pzhetrd which uses tailored codes (either the serial, zhetrd, or the parallel code, pzhettrd the serial version zlacon has been contributed by nick higham march 16, 1988. the serial version was contributed to lapack by nick higham for us |
| series series pclaswp performs a series of row or column interchanges o interchange is initiated for each of rows or columns k1 trough k2 of pdlaswp performs a series of row or column interchanges o interchange is initiated for each of rows or columns k1 trough k2 of pslaswp performs a series of row or column interchanges o interchange is initiated for each of rows or columns k1 trough k2 of pzlaswp performs a series of row or column interchanges o interchange is initiated for each of rows or columns k1 trough k2 of |
| serious serious enough space to compute all the eigenvectors orthogonally will cause serious degradation i pcstein will perform no better than cstein on 1 enough space to compute all the eigenvectors orthogonally will cause serious degradation i pcstein will perform no better than cstein on 1 processor. enough space to compute all the eigenvectors orthogonally will cause serious degradation i pdstein will perform no better than dstein on 1 enough space to compute all the eigenvectors orthogonally will cause serious degradation i pdstein will perform no better than dstein on 1 processor. enough space to compute all the eigenvectors orthogonally will cause serious degradation i psstein will perform no better than sstein on 1 enough space to compute all the eigenvectors orthogonally will cause serious degradation i psstein will perform no better than sstein on 1 processor. enough space to compute all the eigenvectors orthogonally will cause serious degradation i pzstein will perform no better than zstein on 1 enough space to compute all the eigenvectors orthogonally will cause serious degradation i pzstein will perform no better than zstein on 1 processor. |
| serve serve lihiz (local input) integer these serve the same purpose as itmp1,itmp2 but for lihiz (local input) integer these serve the same purpose as itmp1,itmp2 but for lihiz (local input) integer these serve the same purpose as itmp1,itmp2 but for lihiz (local input) integer these serve the same purpose as itmp1,itmp2 but for |
| serves serves tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o |
| set set on entry, the matrix a in band storage, in rows kl+1 to 2*kl+ku+1; rows 1 to kl of the array need not be set array ab as follows: the block size must not exceed the limit set by the size of th set machine-dependent constants for the stopping criterion on entry, the second matrix to receive column reflections. this is changed only if wantz is set ldz (local input) integer on entry, the matrix a in band storage, in rows kl+1 to 2*kl+ku+1; rows 1 to kl of the array need not be set array ab as follows: the block size must not exceed the limit set by the size of th on entry, the second matrix to receive column reflections. this is changed only if wantz is set ldz (local input) integer info (local input) integer this is set if the input matrix had an odd number of rea matrix s was not originally in schur form. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. temporarily set the descriptor type to 1xp typ temporarily set the descriptor type to 1xp typ want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. and ja+jhi:ja+n-1. see further details. if n > 0, 1 <= ilo <= ihi <= n; otherwise set ilo = 1, ihi = n a (local input/local output) complex pointer into the and ja+ihi:ja+n-1. see further details. if n > 0, 1 <= ilo <= ihi <= n; otherwise set ilo = 1, ihi = n a (local input/local output) complex pointer into the abstol (global input) real if jobz='v', setting abstol to pslamch( context, 'u') yield abstol (global input) real if jobz='v', setting abstol to pslamch( context, 'u') yield temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo contains on exit the local pieces of the distributed matrix sub( b ) set as follows if uplo = 'u', b(ib+i-1,jb+j-1) = a(ia+i-1,ja+j-1), contains on exit the local pieces of the distributed matrix sub( b ) set as follows if uplo = 'u', b(ib+i-1,jb+j-1) = a(ia+i-1,ja+j-1), the eigenvectors on input. each eigenvector resides entirely in one process. each process holds a contiguous set o process holds is: sum for i=[0,iam-1) of nvs(i) set work array indice i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore of the distributed submatrix sub( a ). when m = 0, pclange is set to zero. m >= 0 n (global input) integer specifies the part of the distributed matrix sub( a ) to be set triangular part of sub( a ) is not changed; pclaset initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. pclasmsub looks for a small subdiagonal element from the bottom of the matrix that it can safely set to zero notes m(j) could overflow, set xbnd to 0 want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. temporarily set the descriptor type to 1xp typ temporarily set the descriptor type to 1xp typ eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to psstebz ) to select the eigenvector corresponding to the j-th eigenvalue, select(j) must be set to .true. n (global input) integer want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. temporarily set the descriptor type to 1xp typ temporarily set the descriptor type to 1xp typ want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. and ja+jhi:ja+n-1. see further details. if n > 0, 1 <= ilo <= ihi <= n; otherwise set ilo = 1, ihi = n a (local input/local output) double precision pointer into the and ja+ihi:ja+n-1. see further details. if n > 0, 1 <= ilo <= ihi <= n; otherwise set ilo = 1, ihi = n a (local input/local output) double precision pointer into the contains on exit the local pieces of the distributed matrix sub( b ) set as follows if uplo = 'u', b(ib+i-1,jb+j-1) = a(ia+i-1,ja+j-1), contains on exit the local pieces of the distributed matrix sub( b ) set as follows if uplo = 'u', b(ib+i-1,jb+j-1) = a(ia+i-1,ja+j-1), pdlaed2 sorts the two sets of eigenvalues together into a singl there are two ways in which deflation can occur: when two or more the eigenvectors on input. each eigenvector resides entirely in one process. each process holds a contiguous set o process holds is: sum for i=[0,iam-1) of nvs(i) set work array indice i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore of the distributed submatrix sub( a ). when m = 0, pdlange is set to zero. m >= 0 n (global input) integer specifies the part of the distributed matrix sub( a ) to be set triangular part of sub( a ) is not changed; pdlaset initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. pdlasmsub looks for a small subdiagonal element from the bottom of the matrix that it can safely set to zero notes want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. temporarily set the descriptor type to 1xp typ temporarily set the descriptor type to 1xp typ note : it is assumed that the user is on an ieee machine. if the user is not on an ieee mchine, set the compile time flag no_iee are needed for the "fast" sturm count are : (a) infinity eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to pdstebz ) abstol (global input) double precision if jobz='v', setting abstol to pdlamch( context, 'u') yield abstol (global input) double precision if jobz='v', setting abstol to pdlamch( context, 'u') yield temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo this version provides a set of parameters which should give good computers. users are encouraged to modify this subroutine to set want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. temporarily set the descriptor type to 1xp typ temporarily set the descriptor type to 1xp typ want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. and ja+jhi:ja+n-1. see further details. if n > 0, 1 <= ilo <= ihi <= n; otherwise set ilo = 1, ihi = n a (local input/local output) real pointer into the and ja+ihi:ja+n-1. see further details. if n > 0, 1 <= ilo <= ihi <= n; otherwise set ilo = 1, ihi = n a (local input/local output) real pointer into the contains on exit the local pieces of the distributed matrix sub( b ) set as follows if uplo = 'u', b(ib+i-1,jb+j-1) = a(ia+i-1,ja+j-1), contains on exit the local pieces of the distributed matrix sub( b ) set as follows if uplo = 'u', b(ib+i-1,jb+j-1) = a(ia+i-1,ja+j-1), pslaed2 sorts the two sets of eigenvalues together into a singl there are two ways in which deflation can occur: when two or more the eigenvectors on input. each eigenvector resides entirely in one process. each process holds a contiguous set o process holds is: sum for i=[0,iam-1) of nvs(i) set work array indice i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore of the distributed submatrix sub( a ). when m = 0, pslange is set to zero. m >= 0 n (global input) integer specifies the part of the distributed matrix sub( a ) to be set triangular part of sub( a ) is not changed; pslaset initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. pslasmsub looks for a small subdiagonal element from the bottom of the matrix that it can safely set to zero notes want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. temporarily set the descriptor type to 1xp typ temporarily set the descriptor type to 1xp typ note : it is assumed that the user is on an ieee machine. if the user is not on an ieee mchine, set the compile time flag no_iee are needed for the "fast" sturm count are : (a) infinity eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to psstebz ) abstol (global input) real if jobz='v', setting abstol to pslamch( context, 'u') yield abstol (global input) real if jobz='v', setting abstol to pslamch( context, 'u') yield temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. temporarily set the descriptor type to 1xp typ temporarily set the descriptor type to 1xp typ want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. and ja+jhi:ja+n-1. see further details. if n > 0, 1 <= ilo <= ihi <= n; otherwise set ilo = 1, ihi = n a (local input/local output) complex*16 pointer into the and ja+ihi:ja+n-1. see further details. if n > 0, 1 <= ilo <= ihi <= n; otherwise set ilo = 1, ihi = n a (local input/local output) complex*16 pointer into the abstol (global input) double precision if jobz='v', setting abstol to pdlamch( context, 'u') yield abstol (global input) double precision if jobz='v', setting abstol to pdlamch( context, 'u') yield temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo contains on exit the local pieces of the distributed matrix sub( b ) set as follows if uplo = 'u', b(ib+i-1,jb+j-1) = a(ia+i-1,ja+j-1), contains on exit the local pieces of the distributed matrix sub( b ) set as follows if uplo = 'u', b(ib+i-1,jb+j-1) = a(ia+i-1,ja+j-1), the eigenvectors on input. each eigenvector resides entirely in one process. each process holds a contiguous set o process holds is: sum for i=[0,iam-1) of nvs(i) set work array indice i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore of the distributed submatrix sub( a ). when m = 0, pzlange is set to zero. m >= 0 n (global input) integer specifies the part of the distributed matrix sub( a ) to be set triangular part of sub( a ) is not changed; pzlaset initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. pzlasmsub looks for a small subdiagonal element from the bottom of the matrix that it can safely set to zero notes m(j) could overflow, set xbnd to 0 want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. temporarily set the descriptor type to 1xp typ temporarily set the descriptor type to 1xp typ eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to pdstebz ) to select the eigenvector corresponding to the j-th eigenvalue, select(j) must be set to .true. n (global input) integer on entry, the matrix a in band storage, in rows kl+1 to 2*kl+ku+1; rows 1 to kl of the array need not be set array ab as follows: the block size must not exceed the limit set by the size of th on entry, the second matrix to receive column reflections. this is changed only if wantz is set ldz (local input) integer info (local input) integer this is set if the input matrix had an odd number of rea matrix s was not originally in schur form. on entry, the matrix a in band storage, in rows kl+1 to 2*kl+ku+1; rows 1 to kl of the array need not be set array ab as follows: the block size must not exceed the limit set by the size of th set machine-dependent constants for the stopping criterion on entry, the second matrix to receive column reflections. this is changed only if wantz is set ldz (local input) integer |
| sets sets 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. pdlaed2 sorts the two sets of eigenvalues together into a singl there are two ways in which deflation can occur: when two or more 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. pslaed2 sorts the two sets of eigenvalues together into a singl there are two ways in which deflation can occur: when two or more 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. |
| setting setting abstol (global input) real if jobz='v', setting abstol to pslamch( context, 'u') yield abstol (global input) real if jobz='v', setting abstol to pslamch( context, 'u') yield eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to psstebz ) eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to pdstebz ) abstol (global input) double precision if jobz='v', setting abstol to pdlamch( context, 'u') yield abstol (global input) double precision if jobz='v', setting abstol to pdlamch( context, 'u') yield eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to psstebz ) abstol (global input) real if jobz='v', setting abstol to pslamch( context, 'u') yield abstol (global input) real if jobz='v', setting abstol to pslamch( context, 'u') yield abstol (global input) double precision if jobz='v', setting abstol to pdlamch( context, 'u') yield abstol (global input) double precision if jobz='v', setting abstol to pdlamch( context, 'u') yield eigenvalues are computed to highest accuracy ( this can be done by setting abstol to the underflow threshold to pdstebz ) |
| several several claref applies one or several householder reflectors of size rows or columns. dlaref applies one or several householder reflectors of size rows or columns. where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n' and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand sid when trans = 'n', the solution vectors are stored as the columns of when we hit a border, there are row and column transforms that overlap over several processors and the code gets ver *local* matrix is generated on one node (called smalla) and where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n' and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand sid when trans = 'n', the solution vectors are stored as the columns of sort the eigenpairs so that they are in twos for double shifts. only call if several need sortin where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n' and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand sid when trans = 'n', the solution vectors are stored as the columns of sort the eigenpairs so that they are in twos for double shifts. only call if several need sortin where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n' and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand sid when trans = 'n', the solution vectors are stored as the columns of when we hit a border, there are row and column transforms that overlap over several processors and the code gets ver *local* matrix is generated on one node (called smalla) and slaref applies one or several householder reflectors of size rows or columns. zlaref applies one or several householder reflectors of size rows or columns. |
| sfmin sfmin = 'e' or 'e', pdlamch := eps = 's' or 's , pdlamch := sfmin = 'p' or 'p', pdlamch := eps*base = 'e' or 'e', pslamch := eps = 's' or 's , pslamch := sfmin = 'p' or 'p', pslamch := eps*base |
| SGEBR2D SGEBR2D the first column of a send data and only processes that own the first column of b receive data. the calls to sgebs2d/SGEBR2D |
| SGEBS2D SGEBS2D the first column of a send data and only processes that own the first column of b receive data. the calls to SGEBS2D/sgebr2 |
| SGSUM2D SGSUM2D the above formula allows tau to be spread down in the same call to SGSUM2D which performs the sum-to-all of c the computation of v, which could be performed in any processor the above formula allows tau to be spread down in the same call to SGSUM2D which performs the sum-to-all of c the computation of v, which could be performed in any processor |
| shape shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape convert descriptor into standard form for easy access to parameters, check that grid is of right shape |
| shift shift exceptional shift s = abs( real( h( i,i-1 ) ) ) + abs( real( h( i-1,i-2 ) ) ) clamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges form shift dlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges save the shift to check eigenvalue spacing at nex form shift pclaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. copy submatrix of size 2*jblk and prepare to do generalized wilkinson shift or an exceptional shif h43h34 (global input) complex these three values are for the double shift qr iteration pdlaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. copy submatrix of size 2*jblk and prepare to do generalized wilkinson shift or an exceptional shif sigma (input) double precision the shift. pdlapdct finds the number of eigenvalues of t les h43h34 (global input) double precision these three values are for the double shift qr iteration pslaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. copy submatrix of size 2*jblk and prepare to do generalized wilkinson shift or an exceptional shif sigma (input) real the shift. pslapdct finds the number of eigenvalues of t les h43h34 (global input) real these three values are for the double shift qr iteration pzlaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. copy submatrix of size 2*jblk and prepare to do generalized wilkinson shift or an exceptional shif h43h34 (global input) complex*16 these three values are for the double shift qr iteration slamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges save the shift to check eigenvalue spacing at nex form shift exceptional shift s = abs( dble( h( i,i-1 ) ) ) + abs( dble( h( i-1,i-2 ) ) ) zlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges form shift |
| shifts shifts clamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges dlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges dlasorte sorts eigenpairs so that real eigenpairs are together and complex are together. this way one can employ 2x2 shifts easil this routine does no parallel work. sort the eigenpairs so that they are in twos for double shifts. only call if several need sortin sort the eigenpairs so that they are in twos for double shifts. only call if several need sortin slamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges slasorte sorts eigenpairs so that real eigenpairs are together and complex are together. this way one can employ 2x2 shifts easil this routine does no parallel work. zlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges |
| shorten shorten one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 |
| should should set machine-dependent constants for the stopping criterion. if norm(h) <= sqrt(ovfl), overflow should not occur that can be sent through. clamsh should only be called when there are multiple shifts/bulge unreduced hessenberg matrix because of two or more consecutive that can be sent through. dlamsh should only be called when there are multiple shifts/bulge unreduced hessenberg matrix because of two or more consecutive small such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a in the following comments, the character _ should be read a block cyclicly distributed matrix. its description vector is desca: some alignment properties, namely the following expression should be true iroffa.eq.0 .and.iroffa.eq.iroffz. and. iarow.eq.izrow) such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a set machine-dependent constants for the stopping criterion. if norm(h) <= sqrt(ovfl), overflow should not occur i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore such a global array has an associated description vector desca. in the following comments, the character _ should be read a pivoting. the pivot vector may be distributed across a process row or a column. the pivot vector should be aligned with the distribute for example if the row pivots should be applied to the columns of a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pivot vector should be aligned with the distributed matrix a. fo process column and replicated over all process rows. similarly, such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a no communication is performed by this routine, the matrix to operate on should be strictly local to one process notes such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a pctrti2 computes the inverse of a complex upper or lower triangular block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should b such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a small, i.e., converged. note : this should be at least radix*machine epsilon pivmin (input) double precision small, i.e., converged. note : this should be at least radix*machine epsilon ===================================================================== such a global array has an associated description vector desca. in the following comments, the character _ should be read a set machine-dependent constants for the stopping criterion. if norm(h) <= sqrt(ovfl), overflow should not occur i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore such a global array has an associated description vector desca. in the following comments, the character _ should be read a than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest accuracy, it should not be much smalle pivoting. the pivot vector may be distributed across a process row or a column. the pivot vector should be aligned with the distribute for example if the row pivots should be applied to the columns of a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pivot vector should be aligned with the distributed matrix a. fo process column and replicated over all process rows. similarly, such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a no communication is performed by this routine, the matrix to operate on should be strictly local to one process notes such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a note : if eigenvectors are desired later by inverse iteration
( pdstein ), abstol should be set to 2*pdlamch('s')
d (global input) double precision array, dimension (n)
such a global array has an associated description vector desca. in the following comments, the character _ should be read a in the following comments, the character _ should be read a block cyclicly distributed matrix. its description vector is desca: some alignment properties, namely the following expression should be true iroffa.eq.0 .and.iroffa.eq.iroffz. and. iarow.eq.izrow) such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a pdtrti2 computes the inverse of a real upper or lower triangular block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should b such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a this version provides a set of parameters which should give good computers. users are encouraged to modify this subroutine to set such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a small, i.e., converged. note : this should be at least radix*machine epsilon pivmin (input) real small, i.e., converged. note : this should be at least radix*machine epsilon ===================================================================== such a global array has an associated description vector desca. in the following comments, the character _ should be read a set machine-dependent constants for the stopping criterion. if norm(h) <= sqrt(ovfl), overflow should not occur i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore such a global array has an associated description vector desca. in the following comments, the character _ should be read a than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest accuracy, it should not be much smalle pivoting. the pivot vector may be distributed across a process row or a column. the pivot vector should be aligned with the distribute for example if the row pivots should be applied to the columns of a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pivot vector should be aligned with the distributed matrix a. fo process column and replicated over all process rows. similarly, such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a no communication is performed by this routine, the matrix to operate on should be strictly local to one process notes such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a note : if eigenvectors are desired later by inverse iteration
( psstein ), abstol should be set to 2*pslamch('s')
d (global input) real array, dimension (n)
such a global array has an associated description vector desca. in the following comments, the character _ should be read a in the following comments, the character _ should be read a block cyclicly distributed matrix. its description vector is desca: some alignment properties, namely the following expression should be true iroffa.eq.0 .and.iroffa.eq.iroffz. and. iarow.eq.izrow) such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a pstrti2 computes the inverse of a real upper or lower triangular block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should b such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a in the following comments, the character _ should be read a block cyclicly distributed matrix. its description vector is desca: some alignment properties, namely the following expression should be true iroffa.eq.0 .and.iroffa.eq.iroffz. and. iarow.eq.izrow) such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a set machine-dependent constants for the stopping criterion. if norm(h) <= sqrt(ovfl), overflow should not occur i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore such a global array has an associated description vector desca. in the following comments, the character _ should be read a pivoting. the pivot vector may be distributed across a process row or a column. the pivot vector should be aligned with the distribute for example if the row pivots should be applied to the columns of a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pivot vector should be aligned with the distributed matrix a. fo process column and replicated over all process rows. similarly, such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a no communication is performed by this routine, the matrix to operate on should be strictly local to one process notes such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a pztrti2 computes the inverse of a complex upper or lower triangular block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should b such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a that can be sent through. slamsh should only be called when there are multiple shifts/bulge unreduced hessenberg matrix because of two or more consecutive small set machine-dependent constants for the stopping criterion. if norm(h) <= sqrt(ovfl), overflow should not occur that can be sent through. zlamsh should only be called when there are multiple shifts/bulge unreduced hessenberg matrix because of two or more consecutive |
| shown shown in the following code, the row sums created by --- rows below are refered to as rowsums, and the column sums shown by | are refere in the following code, the row sums created by --- rows below are refered to as rowsums, and the column sums shown by | are refere in the following code, the row sums created by --- rows below are refered to as rowsums, and the column sums shown by | are refere performance can decrease as the workspace provided increases above the workspace amount shown below for optimal performance, greater workspace may be performance can decrease as the workspace provided increases above the workspace amount shown below for optimal performance, greater workspace may be in the following code, the row sums created by --- rows below are refered to as rowsums, and the column sums shown by | are refere performance can decrease as the workspace provided increases above the workspace amount shown below for optimal performance, greater workspace may be performance can decrease as the workspace provided increases above the workspace amount shown below for optimal performance, greater workspace may be in the following code, the row sums created by --- rows below are refered to as rowsums, and the column sums shown by | are refere in the following code, the row sums created by --- rows below are refered to as rowsums, and the column sums shown by | are refere |
| SIAM SIAM on distributed memory architectures", SIAM j. sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps on distributed memory architectures", SIAM j. sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps on distributed memory architectures", SIAM j. sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps on distributed memory architectures", SIAM j. sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps on distributed memory architectures", SIAM j. sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps on distributed memory architectures", SIAM j. sci. comput., 6:20 (1999), pp. 2223--2236 http://www.netlib.org/lapack/lawns/lawn132.ps |
| side side nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column normalize and scale the righthand side vector pb receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s use factorization of odd-even connection block to modify locally stored portion of right hand side(s backsolve left side where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n' and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side when trans = 'n', the solution vectors are stored as the columns of nrhs (global input) integer the number of right hand sides, i.e., the number of column pcunmbr(qln), and pcunmbr(prt), where qln and prt are the values of the arguments vect, side, and trans in the cal the matrix u when distributed 1-dimensional "column" of nrhs (global input) integer the number of right-hand sides, i.e., the number of column x(ix:ix+n-1,jx:jx+nrhs-1). nrhs >= 0. side (global input) characte = 'r': apply q or q**h from the right. side (global input) characte = 'r': apply q or q**h from the right. receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s nrhs (global input) integer the number of right hand sides, i.e., the number of column receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s side (global input) character* = 'l': compute left eigenvectors only; nrhs (global input) integer the number of right hand sides, i.e., the number of column side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s use factorization of odd-even connection block to modify locally stored portion of right hand side(s backsolve left side where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n' and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side when trans = 'n', the solution vectors are stored as the columns of nrhs (global input) integer the number of right hand sides, i.e., the number of column pdormbr(qln), and pdormbr(prt), where qln and prt are the values of the arguments vect, side, and trans in the cal the matrix u when distributed 1-dimensional "column" of nrhs (global input) integer the number of right-hand sides, i.e., the number of column x(ix:ix+n-1,jx:jx+nrhs-1). nrhs >= 0. side (global input) characte = 'r': apply q or q**t from the right. side (global input) characte = 'r': apply q or q**t from the right. side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s nrhs (global input) integer the number of right hand sides, i.e., the number of column receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s sizemqrleft = the workspace requirement for pdormtr when it's side argument is 'l' with myprowc defined when a new context is created as: nrhs (global input) integer the number of right hand sides, i.e., the number of column receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s use factorization of odd-even connection block to modify locally stored portion of right hand side(s backsolve left side where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n' and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side when trans = 'n', the solution vectors are stored as the columns of nrhs (global input) integer the number of right hand sides, i.e., the number of column psormbr(qln), and psormbr(prt), where qln and prt are the values of the arguments vect, side, and trans in the cal the matrix u when distributed 1-dimensional "column" of nrhs (global input) integer the number of right-hand sides, i.e., the number of column x(ix:ix+n-1,jx:jx+nrhs-1). nrhs >= 0. side (global input) characte = 'r': apply q or q**t from the right. side (global input) characte = 'r': apply q or q**t from the right. side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t side = 'l' side = 'r trans = 't': q**t * sub( c ) sub( c ) * q**t receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s nrhs (global input) integer the number of right hand sides, i.e., the number of column receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s sizemqrleft = the workspace requirement for psormtr when it's side argument is 'l' with myprowc defined when a new context is created as: nrhs (global input) integer the number of right hand sides, i.e., the number of column receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s use factorization of odd-even connection block to modify locally stored portion of right hand side(s backsolve left side where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n' and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side when trans = 'n', the solution vectors are stored as the columns of nrhs (global input) integer the number of right hand sides, i.e., the number of column pzunmbr(qln), and pzunmbr(prt), where qln and prt are the values of the arguments vect, side, and trans in the cal the matrix u when distributed 1-dimensional "column" of nrhs (global input) integer the number of right-hand sides, i.e., the number of column x(ix:ix+n-1,jx:jx+nrhs-1). nrhs >= 0. side (global input) characte = 'r': apply q or q**h from the right. side (global input) characte = 'r': apply q or q**h from the right. receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s nrhs (global input) integer the number of right hand sides, i.e., the number of column receive previously transmitted matrix section, which forms the right-hand-side for the triangular solve that calculate use factorization of odd-even connection block to modify locally stored portion of right hand side(s side (global input) character* = 'l': compute left eigenvectors only; nrhs (global input) integer the number of right hand sides, i.e., the number of column side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h side = 'l' side = 'r trans = 'c': q**h * sub( c ) sub( c ) * q**h nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column normalize and scale the righthand side vector pb nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column |
| sides sides nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e. the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right-hand sides, i.e., the number of column x(ix:ix+n-1,jx:jx+nrhs-1). nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e. the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right-hand sides, i.e., the number of column x(ix:ix+n-1,jx:jx+nrhs-1). nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e. the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right-hand sides, i.e., the number of column x(ix:ix+n-1,jx:jx+nrhs-1). nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e. the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right-hand sides, i.e., the number of column x(ix:ix+n-1,jx:jx+nrhs-1). nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs >= 0. send modifications to prior processor's right hand sides nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (global input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column nrhs (input) integer the number of right hand sides, i.e., the number of column |
| SIGMA SIGMA a = u * SIGMA * transpose(v where sigma is an m-by-n matrix which is zero except for its a = u * SIGMA * transpose(v where sigma is an m-by-n matrix which is zero except for its pdlapdct counts the number of negative eigenvalues of (t - SIGMA i) the innermost loop to avoid overflow and determine the sign of a a = u * SIGMA * transpose(v where sigma is an m-by-n matrix which is zero except for its pslapdct counts the number of negative eigenvalues of (t - SIGMA i) the innermost loop to avoid overflow and determine the sign of a a = u * SIGMA * transpose(v where sigma is an m-by-n matrix which is zero except for its |
| sign sign this implementation of the sturm sequence loop has conditionals in the innermost loop to avoid overflow and determine the sign of implementation of the sturm sequence loop. are needed for the "fast" sturm count are : (a) infinity arithmetic (b) the sign bit of a single precision floatin (c) the sign of negative zero. this implementation of the sturm sequence loop has conditionals in the innermost loop to avoid overflow and determine the sign of implementation of the sturm sequence loop. are needed for the "fast" sturm count are : (a) infinity arithmetic (b) the sign bit of a double precision floatin (c) the sign of negative zero. |
| significant significant it is the minimum value of lwork input on different processes that is significant if lwork = -1, then lwork is global input and a workspace it is the minimum value of lwork input on different processes that is significant if lwork = -1, then lwork is global input and a workspace it is the minimum value of lwork input on different processes that is significant if lwork = -1, then lwork is global input and a workspace it is the minimum value of lwork input on different processes that is significant if lwork = -1, then lwork is global input and a workspace |
| Similar Similar the eigenvalues. the resulting matrix is no longer Similar to the input lds (local input) integer process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. the eigenvalues. the resulting matrix is no longer Similar to the input lds (local input) integer |
| similarity similarity 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). 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 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 ). 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). k-th subdiagonal are zero. the reduction is performed by an orthogo- nal similarity transformation q' * a * q. the routine returns th and also the matrix y = a * v * t. matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) to symmetric tridiagonal form by an orthogonal similarity transformation q' * sub( a ) * q transformation to the unreduced part of sub( a ). pdsyntrd reduces a real symmetric matrix sub( a ) to symmetric tridiagonal form t by an orthogonal similarity transformation pdsytd2 reduces a real symmetric matrix sub( a ) to symmetric tridiagonal form t by an orthogonal similarity transformation pdsytrd reduces a real symmetric matrix sub( a ) to symmetric tridiagonal form t by an orthogonal similarity transformation pdsyttrd reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation 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). k-th subdiagonal are zero. the reduction is performed by an orthogo- nal similarity transformation q' * a * q. the routine returns th and also the matrix y = a * v * t. matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) to symmetric tridiagonal form by an orthogonal similarity transformation q' * sub( a ) * q transformation to the unreduced part of sub( a ). pssyntrd reduces a real symmetric matrix sub( a ) to symmetric tridiagonal form t by an orthogonal similarity transformation pssytd2 reduces a real symmetric matrix sub( a ) to symmetric tridiagonal form t by an orthogonal similarity transformation pssytrd reduces a real symmetric matrix sub( a ) to symmetric tridiagonal form t by an orthogonal similarity transformation pssyttrd reduces a complex hermitian matrix sub( a ) to hermitian tridiagonal form t by an unitary similarity transformation 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). 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 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 ). |
| Similarly Similarly process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. the number of elements of k that a process would receive if k were distributed over the r processes of its process column. Similarly receive if k were distributed over the c processes of its process process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locq( k ) denotes the number of elements of k that of its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. Similarly all process columns for column pivoting. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. the number of elements of k that a process would receive if k were distributed over the r processes of its process column. Similarly receive if k were distributed over the c processes of its process process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. Similarly all process columns for column pivoting. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locq( k ) denotes the number of elements of k that of its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. the number of elements of k that a process would receive if k were distributed over the r processes of its process column. Similarly receive if k were distributed over the c processes of its process process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. Similarly all process columns for column pivoting. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locq( k ) denotes the number of elements of k that of its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. the number of elements of k that a process would receive if k were distributed over the r processes of its process column. Similarly receive if k were distributed over the c processes of its process process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locq( k ) denotes the number of elements of k that of its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. Similarly all process columns for column pivoting. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. process column. Similarly, locc( k ) denotes the number of elements of k that its process row. |
| simple simple at present, ia, ja, mb and nb are restricted to those values allowed by pchetrd to keep the interface simple. these restrictions ar at present, ia, ja, mb and nb are restricted to those values allowed by pdsytrd to keep the interface simple. these restrictions ar at present, ia, ja, mb and nb are restricted to those values allowed by pssytrd to keep the interface simple. these restrictions ar at present, ia, ja, mb and nb are restricted to those values allowed by pzhetrd to keep the interface simple. these restrictions ar |
| simpler simpler work is done on that. at the end of the border, the data is passed back and everything stays a lot simpler work is done on that. at the end of the border, the data is passed back and everything stays a lot simpler work is done on that. at the end of the border, the data is passed back and everything stays a lot simpler work is done on that. at the end of the border, the data is passed back and everything stays a lot simpler |
| simplifies simplifies the scaling factor are stored along process rows in sr and along process columns in sc. the duplication of information simplifies the scaling factor are stored along process rows in sr and along process columns in sc. the duplication of information simplifies the scaling factor are stored along process rows in sr and along process columns in sc. the duplication of information simplifies the scaling factor are stored along process rows in sr and along process columns in sc. the duplication of information simplifies |
| simplify simplify one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 one-dimensional descriptors are a new addition to scalapack since version 1.0. they simplify and shorten the descriptor for 1 |
| simultaneously simultaneously single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the single descriptor, desca, serves to describe the distribution of of all diagonals simultaneously important note: the actual blacs grid represented by the |
| Since Since complex are together. this way one can employ 2x2 shifts easily Since every 2nd subdiagonal is guaranteed to be zero one-dimensional descriptors are a new addition to scalapack Since arrays. as per requirements of blas routine ctrmm. Since we have gu_i stored one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. work ( invt ), or v^t, is stored as a tall skinny array ( nq x anb-1 ) for efficiency. Since only the lowe tril(a) * v + v^t * tril(a,-1). this is performed as h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and h(m+2,m-1). Since these elements may be on separat and has each node store whatever values of the 7 it has that find normi( sub( a ) ) ( = norm1( sub( a ) ), Since sub( a ) i find normi( sub( a ) ) ( = norm1( sub( a ) ), Since sub( a ) i one-dimensional descriptors are a new addition to scalapack Since arrays. as per requirements of blas routine ctrmm. Since we have g_i^c stored, conjugate transpos one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. Since there is no element-by-element vector multiplication i one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. as per requirements of blas routine dtrmm. Since we have gu_i stored one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and h(m+2,m-1). Since these elements may be on separat and has each node store whatever values of the 7 it has that find normi( sub( a ) ) ( = norm1( sub( a ) ), Since sub( a ) i one-dimensional descriptors are a new addition to scalapack Since arrays. as per requirements of blas routine dtrmm. Since we have g_i^t stored, transpos one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. Since there is no element-by-element vector multiplication i one-dimensional descriptors are a new addition to scalapack Since arrays. (only the first nsplit elements will actually be used, but Since the user cannot know a priori what value nsplit wil work ( invt ), or v^t, is stored as a tall skinny array ( nq x anb-1 ) for efficiency. Since only the lowe tril(a) * v + v^t * tril(a,-1). this is performed as one-dimensional descriptors are a new addition to scalapack Since arrays. as per requirements of blas routine dtrmm. Since we have gu_i stored one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and h(m+2,m-1). Since these elements may be on separat and has each node store whatever values of the 7 it has that find normi( sub( a ) ) ( = norm1( sub( a ) ), Since sub( a ) i one-dimensional descriptors are a new addition to scalapack Since arrays. as per requirements of blas routine strmm. Since we have g_i^t stored, transpos one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. Since there is no element-by-element vector multiplication i one-dimensional descriptors are a new addition to scalapack Since arrays. (only the first nsplit elements will actually be used, but Since the user cannot know a priori what value nsplit wil work ( invt ), or v^t, is stored as a tall skinny array ( nq x anb-1 ) for efficiency. Since only the lowe tril(a) * v + v^t * tril(a,-1). this is performed as one-dimensional descriptors are a new addition to scalapack Since arrays. as per requirements of blas routine ztrmm. Since we have gu_i stored one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. work ( invt ), or v^t, is stored as a tall skinny array ( nq x anb-1 ) for efficiency. Since only the lowe tril(a) * v + v^t * tril(a,-1). this is performed as h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and h(m+2,m-1). Since these elements may be on separat and has each node store whatever values of the 7 it has that find normi( sub( a ) ) ( = norm1( sub( a ) ), Since sub( a ) i find normi( sub( a ) ) ( = norm1( sub( a ) ), Since sub( a ) i one-dimensional descriptors are a new addition to scalapack Since arrays. as per requirements of blas routine ztrmm. Since we have g_i^c stored, conjugate transpos one-dimensional descriptors are a new addition to scalapack Since arrays. one-dimensional descriptors are a new addition to scalapack Since arrays. Since there is no element-by-element vector multiplication i one-dimensional descriptors are a new addition to scalapack Since arrays. complex are together. this way one can employ 2x2 shifts easily Since every 2nd subdiagonal is guaranteed to be zero |
| single single look for a single small subdiagonal element clamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges their data from the vecs array. if .false., apply the single reflector given by v2, v3 dlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges their data from the vecs array. if .false., apply the single reflector given by v2, v3 scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side vectors b and solution vectors x can be handled in a single call the n-by-nrhs right hand side matrix sub( b ) and the m-by-nrhs look for a single small subdiagonal element look for a single small subdiagonal element do 20 k = i, l + 1, -1 scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side vectors b and solution vectors x can be handled in a single call the n-by-nrhs right hand side matrix sub( b ) and the m-by-nrhs pdlaed2 sorts the two sets of eigenvalues together into a single there are two ways in which deflation can occur: when two or more look for a single small subdiagonal element look for a single small subdiagonal element do 20 k = i, l + 1, -1 scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o are needed for the "fast" sturm count are : (a) infinity arithmetic (b) the sign bit of a single precision floatin (c) the sign of negative zero. the character options to the subroutine name, concatenated into a single character string. for example, uplo = 'u' be specified as opts = 'utn'. scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side vectors b and solution vectors x can be handled in a single call the n-by-nrhs right hand side matrix sub( b ) and the m-by-nrhs pslaed2 sorts the two sets of eigenvalues together into a single there are two ways in which deflation can occur: when two or more look for a single small subdiagonal element pslamch determines single precision machine parameters arguments look for a single small subdiagonal element do 20 k = i, l + 1, -1 scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side vectors b and solution vectors x can be handled in a single call the n-by-nrhs right hand side matrix sub( b ) and the m-by-nrhs look for a single small subdiagonal element look for a single small subdiagonal element do 20 k = i, l + 1, -1 scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same scalapack routines *do not support intercontext operations* so that the grid passed to a single scalapack routine *must be the same tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o tridiagonal matrix be aligned with each other. because of this, a single descriptor, desca, serves to describe the distribution o slamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges their data from the vecs array. if .false., apply the single reflector given by v2, v3 look for a single small subdiagonal element zlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges their data from the vecs array. if .false., apply the single reflector given by v2, v3 |
| singular singular has been completed, but the factor u is exactly singular, and division by zero will occur if it is use has been completed, but the factor u is exactly singular, and division by zero will occur if it is use has been completed, but the factor u is exactly singular, and division by zero will occur if it is use has been completed, but the factor u is exactly singular, and division by zero will occur if it is use the factorization has been completed, but the factor u is exactly singular, so the solution could not b pcgesvd computes the singular value decomposition (svd) of a singular vectors. the svd is written as rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to working precision the factorization has been completed, but the factor u is exactly singular, and division by zero will occur i the factorization has been completed, but the factor u is exactly singular, and division by zero will occur i > 0: if info = k, u(ia+k-1,ia+k-1) is exactly zero; the matrix is singular and its inverse could not b see "computing small singular values of bidiagonal matrice kahan, lapack working note #3. see "computing small singular values of bidiagonal matrice kahan, lapack working note #3. machine precision (in particular, if rcond = 0), the matrix is singular to working precision. this condition i error bounds are not computed. > 0: if info = k, a(ia+k-1,ja+k-1) is exactly zero. the triangular matrix sub( a ) is singular and it n-by-nrhs distributed matrix denoted by sub( b ). a check is made to verify that sub( a ) is nonsingular notes the factorization has been completed, but the factor u is exactly singular, so the solution could not b pdgesvd computes the singular value decomposition (svd) of a singular vectors. the svd is written as rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to working precision the factorization has been completed, but the factor u is exactly singular, and division by zero will occur i the factorization has been completed, but the factor u is exactly singular, and division by zero will occur i > 0: if info = k, u(ia+k-1,ia+k-1) is exactly zero; the matrix is singular and its inverse could not b machine precision (in particular, if rcond = 0), the matrix is singular to working precision. this condition i error bounds are not computed. see "computing small singular values of bidiagonal matrice kahan, lapack working note #3. see "computing small singular values of bidiagonal matrice kahan, lapack working note #3. > 0: if info = k, a(ia+k-1,ja+k-1) is exactly zero. the triangular matrix sub( a ) is singular and it n-by-nrhs distributed matrix denoted by sub( b ). a check is made to verify that sub( a ) is nonsingular notes the factorization has been completed, but the factor u is exactly singular, so the solution could not b psgesvd computes the singular value decomposition (svd) of a singular vectors. the svd is written as rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to working precision the factorization has been completed, but the factor u is exactly singular, and division by zero will occur i the factorization has been completed, but the factor u is exactly singular, and division by zero will occur i > 0: if info = k, u(ia+k-1,ia+k-1) is exactly zero; the matrix is singular and its inverse could not b machine precision (in particular, if rcond = 0), the matrix is singular to working precision. this condition i error bounds are not computed. see "computing small singular values of bidiagonal matrice kahan, lapack working note #3. see "computing small singular values of bidiagonal matrice kahan, lapack working note #3. > 0: if info = k, a(ia+k-1,ja+k-1) is exactly zero. the triangular matrix sub( a ) is singular and it n-by-nrhs distributed matrix denoted by sub( b ). a check is made to verify that sub( a ) is nonsingular notes the factorization has been completed, but the factor u is exactly singular, so the solution could not b pzgesvd computes the singular value decomposition (svd) of a singular vectors. the svd is written as rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to working precision the factorization has been completed, but the factor u is exactly singular, and division by zero will occur i the factorization has been completed, but the factor u is exactly singular, and division by zero will occur i > 0: if info = k, u(ia+k-1,ia+k-1) is exactly zero; the matrix is singular and its inverse could not b see "computing small singular values of bidiagonal matrice kahan, lapack working note #3. see "computing small singular values of bidiagonal matrice kahan, lapack working note #3. machine precision (in particular, if rcond = 0), the matrix is singular to working precision. this condition i error bounds are not computed. > 0: if info = k, a(ia+k-1,ja+k-1) is exactly zero. the triangular matrix sub( a ) is singular and it n-by-nrhs distributed matrix denoted by sub( b ). a check is made to verify that sub( a ) is nonsingular notes has been completed, but the factor u is exactly singular, and division by zero will occur if it is use has been completed, but the factor u is exactly singular, and division by zero will occur if it is use has been completed, but the factor u is exactly singular, and division by zero will occur if it is use has been completed, but the factor u is exactly singular, and division by zero will occur if it is use |
| singularity singularity find pivot and test for singularity. km is the number o find pivot and test for singularity. km is the number o find pivot and test for singularity. km is the number o find pivot and test for singularity. km is the number o |
| situation situation the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. the divide and conqer algorithm assumes the matrix is narrowly banded compared with the number of equations. in this situation with columns atomic and rows divided amongst the processes. |
| situations situations greater performance can be achieved if adequate workspace is provided. on the other hand, in some situations increases above the workspace amount shown below: greater performance can be achieved if adequate workspace is provided. on the other hand, in some situations increases above the workspace amount shown below: greater performance can be achieved if adequate workspace is provided. on the other hand, in some situations increases above the workspace amount shown below: greater performance can be achieved if adequate workspace is provided. on the other hand, in some situations increases above the workspace amount shown below: |
| size size determine the block size for this environmen is referenced. it is assumed that s has jblk double shifts (size 2) applying. claref applies one or several householder reflectors of size rows or columns. determine the block size for this environmen referenced. it is assumed that s has jblk double shifts (size 2) applying. dlaref applies one or several householder reflectors of size rows or columns. skip all the work if the block size is one be overwritten in between calls to routines. work must be the size given in lwork size of separator blocks is maximum of bandwidth 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 block sizes must be the sam source processor must be the same aligned with d. must be of size >= desca( nb_ ) factors of the matrix. check auxiliary storage size aligned with d. must be of size >= desca( nb_ ) factors of the matrix. block sizes must be the sam source processor must be the same be overwritten in between calls to routines. work must be the size given in lwork check auxiliary storage size 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 query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. nq = number of local columns in a and vt size = min( m, n sizep = number of local rows in vt query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum size for the work array. the required workspace is returne by pxerbla. if lwork = -1, then lwork is global input and a workspace query is assumed; the routine calculates the size for al entry of the corresponding work array, and no error message lwork (local input) integer size of work array. if only eigenvalues are requested if eigenvectors are requested: lwork (local input) integer size of work array. if only eigenvalues are requested if eigenvectors are requested: query is assumed; the routine only calculates the optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. buf (local output) complex array of size lwork lwork (global input) integer b (local input/output) complex array of size (ldb,m a(i:i+m-1,i:i+m-1). in a block cyclic manner in both dimensions, with a block size of nb iz (global input) integer the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already n (global input) integer the size of the matrix to be transposed a (local output) complex*16 pointer into the or 'c' and pivroc='r' or 'r', the last piece of this array of size mb_a (resp. nb_a) is used as workspace. in those cases local row (column) i was swapped with. the last piece of the array of size mb_a (resp. nb_a) is used as workspace. ipiv i large and small are threshold values used to decide if row scaling should be done based on the absolute size of the largest matri large and small are threshold values used to decide if scaling should be done based on the absolute size of the largest matrix element buf (local output) complex array of size lwork lwork (global input) integer v (global output) complex array of size 3 be overwritten in between calls to routines. work must be the size given in lwork check auxiliary storage size 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 block sizes must be the sam source processor must be the same query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. factors of the matrix. must be of size >= desca( nb_ ) e (local input/local output) complex pointer to local check auxiliary storage size factors of the matrix. must be of size >= desca( nb_ ) e (local input/local output) complex pointer to local block sizes must be the sam source processor must be the same nvec = floor(( lwork- max(5*n,np00*mq00) )/n). eigenvectors corresponding to eigenvalue clusters of size orthogonality is similar to that obtained from cstein2). query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. be overwritten in between calls to routines. work must be the size given in lwork size of separator blocks is maximum of bandwidth 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 block sizes must be the sam source processor must be the same aligned with d. must be of size >= desca( nb_ ) factors of the matrix. check auxiliary storage size aligned with d. must be of size >= desca( nb_ ) factors of the matrix. block sizes must be the sam source processor must be the same be overwritten in between calls to routines. work must be the size given in lwork check auxiliary storage size 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 query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. nq = number of local columns in a and vt size = min( m, n sizep = number of local rows in vt query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. buf (local output) double precision array of size lwork lwork (global input) integer b (local input/output) double precision array of size (ldb,m a(i:i+m-1,i:i+m-1). the first stage consists of deflating the size of the proble the z vector. for each such occurence the dimension of the pdlaed2 sorts the two sets of eigenvalues together into a single sorted set. then it tries to deflate the size of the problem eigenvalues are close together or if there is a tiny entry in the in a block cyclic manner in both dimensions, with a block size of nb iz (global input) integer the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already n (global input) integer the size of the matrix to be transposed a (local output) complex*16 pointer into the or 'c' and pivroc='r' or 'r', the last piece of this array of size mb_a (resp. nb_a) is used as workspace. in those cases local row (column) i was swapped with. the last piece of the array of size mb_a (resp. nb_a) is used as workspace. ipiv i large and small are threshold values used to decide if row scaling should be done based on the absolute size of the largest matri large and small are threshold values used to decide if scaling should be done based on the absolute size of the largest matrix element lwork (local input) integer size of work arra lwork (local input) integer size of work arra buf (local output) double precision array of size lwork lwork (global input) integer v (global output) double precision array of size 3 query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. be overwritten in between calls to routines. work must be the size given in lwork check auxiliary storage size 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 block sizes must be the sam source processor must be the same query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. factors of the matrix. must be of size >= desca( nb_ ) e (local input/local output) double precision pointer to local check auxiliary storage size factors of the matrix. must be of size >= desca( nb_ ) e (local input/local output) double precision pointer to local block sizes must be the sam source processor must be the same lwork (local input) integer size of array work must be >= max( 5*n, 7 query is assumed; the routine only calculates the minimum query is assumed; the routine only calculates the minimum size for the work array. the required workspace is returne by pxerbla. nvec = floor(( lwork- max(5*n,np00*mq00) )/n). eigenvectors corresponding to eigenvalue clusters of size orthogonality is similar to that obtained from dstein2). if no eigenvectors are requested (jobz = 'n') then lwork >= 5*n + sizesytrd + sizesytrd = the workspace requirement for pdsytrd query is assumed; the routine only calculates the minimum size for the work array. the required workspace is returne by pxerbla. lwork (local input) integer size of wor if no eigenvectors are requested (jobz = 'n') then the following to lwork: (clustersize-1)* largest cluster, where a cluster is defined as a set of query is assumed; the routine only calculates the optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. the tuning parameters for their particular machine using the option and problem size information in the arguments this routine will not function correctly if it is converted to all be overwritten in between calls to routines. work must be the size given in lwork size of separator blocks is maximum of bandwidth 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 block sizes must be the sam source processor must be the same aligned with d. must be of size >= desca( nb_ ) factors of the matrix. check auxiliary storage size aligned with d. must be of size >= desca( nb_ ) factors of the matrix. block sizes must be the sam source processor must be the same be overwritten in between calls to routines. work must be the size given in lwork check auxiliary storage size 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 query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. nq = number of local columns in a and vt size = min( m, n sizep = number of local rows in vt query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. buf (local output) real array of size lwork lwork (global input) integer b (local input/output) real array of size (ldb,m a(i:i+m-1,i:i+m-1). the first stage consists of deflating the size of the proble the z vector. for each such occurence the dimension of the pslaed2 sorts the two sets of eigenvalues together into a single sorted set. then it tries to deflate the size of the problem eigenvalues are close together or if there is a tiny entry in the in a block cyclic manner in both dimensions, with a block size of nb iz (global input) integer the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already n (global input) integer the size of the matrix to be transposed a (local output) complex*16 pointer into the or 'c' and pivroc='r' or 'r', the last piece of this array of size mb_a (resp. nb_a) is used as workspace. in those cases local row (column) i was swapped with. the last piece of the array of size mb_a (resp. nb_a) is used as workspace. ipiv i large and small are threshold values used to decide if row scaling should be done based on the absolute size of the largest matri large and small are threshold values used to decide if scaling should be done based on the absolute size of the largest matrix element lwork (local input) integer size of work arra lwork (local input) integer size of work arra buf (local output) real array of size lwork lwork (global input) integer v (global output) real array of size 3 query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. be overwritten in between calls to routines. work must be the size given in lwork check auxiliary storage size 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 block sizes must be the sam source processor must be the same query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. factors of the matrix. must be of size >= desca( nb_ ) e (local input/local output) real pointer to local check auxiliary storage size factors of the matrix. must be of size >= desca( nb_ ) e (local input/local output) real pointer to local block sizes must be the sam source processor must be the same lwork (local input) integer size of array work must be >= max( 5*n, 7 query is assumed; the routine only calculates the minimum query is assumed; the routine only calculates the minimum size for the work array. the required workspace is returne by pxerbla. nvec = floor(( lwork- max(5*n,np00*mq00) )/n). eigenvectors corresponding to eigenvalue clusters of size orthogonality is similar to that obtained from sstein2). if no eigenvectors are requested (jobz = 'n') then lwork >= 5*n + sizesytrd + sizesytrd = the workspace requirement for pssytrd query is assumed; the routine only calculates the minimum size for the work array. the required workspace is returne by pxerbla. lwork (local input) integer size of wor if no eigenvectors are requested (jobz = 'n') then the following to lwork: (clustersize-1)* largest cluster, where a cluster is defined as a set of query is assumed; the routine only calculates the optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. be overwritten in between calls to routines. work must be the size given in lwork size of separator blocks is maximum of bandwidth 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 block sizes must be the sam source processor must be the same aligned with d. must be of size >= desca( nb_ ) factors of the matrix. check auxiliary storage size aligned with d. must be of size >= desca( nb_ ) factors of the matrix. block sizes must be the sam source processor must be the same be overwritten in between calls to routines. work must be the size given in lwork check auxiliary storage size 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 query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. nq = number of local columns in a and vt size = min( m, n sizep = number of local rows in vt query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum size for the work array. the required workspace is returne by pxerbla. if lwork = -1, then lwork is global input and a workspace query is assumed; the routine calculates the size for al entry of the corresponding work array, and no error message lwork (local input) integer size of work array. if only eigenvalues are requested if eigenvectors are requested: lwork (local input) integer size of work array. if only eigenvalues are requested if eigenvectors are requested: query is assumed; the routine only calculates the optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. buf (local output) complex*16 array of size lwork lwork (global input) integer b (local input/output) complex*16 array of size (ldb,m a(i:i+m-1,i:i+m-1). in a block cyclic manner in both dimensions, with a block size of nb iz (global input) integer the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already n (global input) integer the size of the matrix to be transposed a (local output) complex*16 pointer into the or 'c' and pivroc='r' or 'r', the last piece of this array of size mb_a (resp. nb_a) is used as workspace. in those cases local row (column) i was swapped with. the last piece of the array of size mb_a (resp. nb_a) is used as workspace. ipiv i large and small are threshold values used to decide if row scaling should be done based on the absolute size of the largest matri large and small are threshold values used to decide if scaling should be done based on the absolute size of the largest matrix element buf (local output) complex*16 array of size lwork lwork (global input) integer v (global output) complex*16 array of size 3 be overwritten in between calls to routines. work must be the size given in lwork check auxiliary storage size 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 block sizes must be the sam source processor must be the same query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. factors of the matrix. must be of size >= desca( nb_ ) e (local input/local output) complex*16 pointer to local check auxiliary storage size factors of the matrix. must be of size >= desca( nb_ ) e (local input/local output) complex*16 pointer to local block sizes must be the sam source processor must be the same nvec = floor(( lwork- max(5*n,np00*mq00) )/n). eigenvectors corresponding to eigenvalue clusters of size orthogonality is similar to that obtained from zstein2). query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work arrays. each of thes work array, and no error message is issued by pxerbla. determine the block size for this environmen referenced. it is assumed that s has jblk double shifts (size 2) applying. slaref applies one or several householder reflectors of size rows or columns. skip all the work if the block size is one determine the block size for this environmen is referenced. it is assumed that s has jblk double shifts (size 2) applying. zlaref applies one or several householder reflectors of size rows or columns. |
| SIZEB SIZEB lwork >= 1 + 2*SIZEB + max(watobd, wbdtosvd) where sizeb = max(m,n), and watobd and wbdtosvd refer, lwork >= 1 + 6*SIZEB + max(watobd, wbdtosvd) where sizeb = max(m,n), and watobd and wbdtosvd refer, lwork >= 1 + 6*SIZEB + max(watobd, wbdtosvd) where sizeb = max(m,n), and watobd and wbdtosvd refer, lwork >= 1 + 2*SIZEB + max(watobd, wbdtosvd) where sizeb = max(m,n), and watobd and wbdtosvd refer, |
| sized sized last processor in an odd-sized npact skips to her last processor in an odd-sized npact skips to her last processor in an odd-sized npact skips to her last processor in an odd-sized npact skips to her |
| SIZEMQRLEFT SIZEMQRLEFT qrmem = 2*n-2 lwmin = 5*n + n*ldc + max( SIZEMQRLEFT, qrmem ) + variable definitions: qrmem = 2*n-2 lwmin = 5*n + n*ldc + max( SIZEMQRLEFT, qrmem ) + variable definitions: |
| SIZEP SIZEP sizeq = number of local columns in u SIZEP = number of local rows in v jobu (global input) character*1 sizeq = number of local columns in u SIZEP = number of local rows in v jobu (global input) character*1 sizeq = number of local columns in u SIZEP = number of local rows in v jobu (global input) character*1 sizeq = number of local columns in u SIZEP = number of local rows in v jobu (global input) character*1 |
| SIZEQ SIZEQ size = min( m, n ) SIZEQ = number of local columns in size = min( m, n ) SIZEQ = number of local columns in size = min( m, n ) SIZEQ = number of local columns in size = min( m, n ) SIZEQ = number of local columns in |
| Sizes Sizes the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a Sizes of the extra triangles communicated bewtween processor the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a Sizes of the extra triangles communicated bewtween processor the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a Sizes of the extra triangles communicated bewtween processor the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a Sizes of the extra triangles communicated bewtween processor the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a Sizes of the extra triangles communicated bewtween processor the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a Sizes of the extra triangles communicated bewtween processor the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a Sizes of the extra triangles communicated bewtween processor the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a Sizes of the extra triangles communicated bewtween processor the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a the matrix a as p a p^t and then factoring the principal leading submatrix of size equal to the sum of the Sizes o these submatrices overwrite the corresponding parts of a block Sizes must be the sam source processor must be the same |
| SIZESYTRD SIZESYTRD if no eigenvectors are requested (jobz = 'n') then lwork >= 5*n + SIZESYTRD + sizesytrd = the workspace requirement for pdsytrd if no eigenvectors are requested (jobz = 'n') then lwork >= 5*n + SIZESYTRD + sizesytrd = the workspace requirement for pssytrd |
| skinny skinny work ( invt ), or v^t, is stored as a tall skinny triangular portion of a is updated, av is computed as: work ( invt ), or v^t, is stored as a tall skinny triangular portion of a is updated, av is computed as: work ( invt ), or v^t, is stored as a tall skinny triangular portion of a is updated, av is computed as: work ( invt ), or v^t, is stored as a tall skinny triangular portion of a is updated, av is computed as: |
| Skip Skip Skip the current step: the subdiagonal info is just noise Skip all the work if the block size is one further optimization is met with the boolean Skip. a borde efficient parallelism: Skip small submatrice if ( m .ge. i - 5 ) Skip small submatrice if ( m .ge. i - 5 ) further optimization is met with the boolean Skip. a borde efficient parallelism: Skip all the work if the block size is one Skip the current step: the subdiagonal info is just noise |
| skipped skipped of the matrix a. if the reciprocal of the condition number is less than machine precision, steps 4-6 are skipped 4. the system of equations is solved for x using the factored form of the matrix a. if the reciprocal of the condition number is less than machine precision, steps 4-6 are skipped 4. the system of equations is solved for x using the factored form of the matrix a. if the reciprocal of the condition number is less than machine precision, steps 4-6 are skipped 4. the system of equations is solved for x using the factored form of the matrix a. if the reciprocal of the condition number is less than machine precision, steps 4-6 are skipped 4. the system of equations is solved for x using the factored form of the matrix a. if the reciprocal of the condition number is less than machine precision, steps 4-6 are skipped 4. the system of equations is solved for x using the factored form of the matrix a. if the reciprocal of the condition number is less than machine precision, steps 4-6 are skipped 4. the system of equations is solved for x using the factored form of the matrix a. if the reciprocal of the condition number is less than machine precision, steps 4-6 are skipped 4. the system of equations is solved for x using the factored form of the matrix a. if the reciprocal of the condition number is less than machine precision, steps 4-6 are skipped 4. the system of equations is solved for x using the factored form |
| skips skips last processor skips to next leve bm1 = m for 1st block on proc pair, bm2 2nd block last processor skips to next leve bm1 = m for 1st block on proc pair, bm2 2nd block last processor skips to next leve bm1 = m for 1st block on proc pair, bm2 2nd block last processor skips to next leve bm1 = m for 1st block on proc pair, bm2 2nd block |
| SLACON SLACON pSLACON estimates the 1-norm of a square, real distributed matrix a x and v are aligned with the distributed matrix a, this information |
| SLAE2 SLAE2 if remaining matrix is 2-by-2, use SLAE2 or slaev if remaining matrix is 2-by-2, use SLAE2 or slaev |
| SLAED3 SLAED3 a copy of the first k eigenvalues which will be used by SLAED3 to form the secular equation w (global output) double precision array, dimension (n) a copy of the first k eigenvalues which will be used by SLAED3 to form the secular equation w (global output) double precision array, dimension (n) on exit, rho has been modified to the value required by pSLAED3 z (global input) real array, dimension (n) pSLAED3 finds the roots of the secular equation, as defined by th appropriate calls to slaed4 it could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. see SLAED3 for details arguments |
| SLAED4 SLAED4 eigenvalues. this is done by finding the roots of the secular equation via the routine SLAED4 (as called by pdlaed3) problem. values in d, w, and rho, between 1 and k. it makes the appropriate calls to SLAED4 this code makes very mild assumptions about floating point eigenvalues. this is done by finding the roots of the secular equation via the routine SLAED4 (as called by pslaed3) problem. values in d, w, and rho, between 1 and k. it makes the appropriate calls to SLAED4 this code makes very mild assumptions about floating point |
| SLAEV2 SLAEV2 if remaining matrix is 2-by-2, use slae2 or SLAEV2 if remaining matrix is 2-by-2, use dlae2 or SLAEV2 if remaining matrix is 2-by-2, use slae2 or SLAEV2 |
| SLAHQR SLAHQR SLAHQR used to have a single row application and a singl more clever. we break each transformation down into 3 this code is basically a parallelization of the following snip of lapack code from SLAHQR look for a single small subdiagonal element. |
| SLAMCH SLAMCH done by setting abstol to the underflow threshold =
SLAMCH('u') --- abstol is an input paramete
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').
done by setting abstol to the underflow threshold =
SLAMCH('u') --- abstol is an input paramete
|
| SLAMSH SLAMSH SLAMSH sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges |
| SLANHS SLANHS if( tst1.eq.zero ) $ tst1 = SLANHS( '1', i-l+1, h( l, l ), ldh, work $ go to 30 |
| SLAREF SLAREF SLAREF applies one or several householder reflectors of size rows or columns. |
| SLARNV SLARNV initialize seed for random number generator SLARNV |
| SLASORTE SLASORTE SLASORTE sorts eigenpairs so that real eigenpairs are together an since every 2nd subdiagonal is guaranteed to be zero. |
| SLASRT2 SLASRT2 end of SLASRT2 |
| slight slight the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error in x(j). the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of th aligned with the matrices b and x. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error largest entry in sub( x ). the estimate is as reliable as the estimate for rcond, and is almost always a slight this array is tied to the distributed matrix x. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error in x(j). the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of th aligned with the matrices b and x. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error largest entry in sub( x ). the estimate is as reliable as the estimate for rcond, and is almost always a slight this array is tied to the distributed matrix x. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error in x(j). the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of th aligned with the matrices b and x. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error largest entry in sub( x ). the estimate is as reliable as the estimate for rcond, and is almost always a slight this array is tied to the distributed matrix x. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error in x(j). the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of th aligned with the matrices b and x. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error largest entry in sub( x ). the estimate is as reliable as the estimate for rcond, and is almost always a slight this array is tied to the distributed matrix x. |
| slightly slightly finally aptr is the pointer to the first element of a. as lapack has a slightly different matrix format than scalapack the pointe finally aptr is the pointer to the first element of a. as lapack has a slightly different matrix format than scalapack the pointe finally aptr is the pointer to the first element of a. as lapack has a slightly different matrix format than scalapack the pointe finally aptr is the pointer to the first element of a. as lapack has a slightly different matrix format than scalapack the pointe |
| SLmake SLmake to a system which does not have ieee 754 arithmetic, modify the appropriate SLmake.inc file to include the compiler switc is not on an ieee mchine, set the compile time flag no_ieee to 1 (in SLmake.inc). the features of ieee arithmetic tha arithmetic (b) the sign bit of a single precision floating to a system which does not have ieee 754 arithmetic, modify the appropriate SLmake.inc file to include the compiler switc is not on an ieee mchine, set the compile time flag no_ieee to 1 (in SLmake.inc). the features of ieee arithmetic tha arithmetic (b) the sign bit of a double precision floating to a system which does not have ieee 754 arithmetic, modify the appropriate SLmake.inc file to include the compiler switc to a system which does not have ieee 754 arithmetic, modify the appropriate SLmake.inc file to include the compiler switc |
| sloppy sloppy used was incorrect. no eigenvalues were computed. probable cause: your machine has sloppy floatin cure: increase the parameter "fudge", recompile, used was incorrect. no eigenvalues were computed. probable cause: your machine has sloppy floatin cure: increase the parameter "fudge", recompile, |
| slow slow support for uplo='u' is limited to calling the old, slow, pchetr support for uplo='u' is limited to calling the old, slow, pdsytr support for uplo='u' is limited to calling the old, slow, pssytr support for uplo='u' is limited to calling the old, slow, pzhetr |
| Small Small look for a single Small subdiagonal element clamsh sends multiple shifts through a Small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges look for Small superdiagonal element dlamsh sends multiple shifts through a Small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges if eigenvalues j and j-1 are too close, add a relatively Small perturbation for each block, according to whether top or bottom diagonal element is Smaller size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b nb*(bwl+bwu)+6*max(bwl,bwu)*max(bwl,bwu) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (max(bwl,bwu)*nrhs) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (12*npcol+3*nb) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b 10*npcol+4*nrhs size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (nb+bwu)*(bwl+bwu)+6*(bwl+bwu)*(bwl+2*bwu) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b nrhs*(nb+2*bwl+4*bwu) r(i) and c(j) are restricted to be between smlnum = Smallest saf factors is not guaranteed to reduce the condition number of il (global input) integer if range='i', the index (from Smallest to largest) of th not referenced if range = 'a' or 'v'. il (global input) integer if range='i', the index (from Smallest to largest) of th not referenced if range = 'a' or 'v'. pchentrd is faster than pchetrd on almost all matrices, particularly Small ones (i.e. n < 500 * sqrt(p) ), provided tha pclaconsb looks for two consecutive Small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a look for a single Small subdiagonal element rowcnd (global input) real the global ratio of the Smallest r(i) to the largest r(i) scond (global input) real ratio of the Smallest sr(i) (respectively sc(j)) to th and ja <= j <= ja+n-1. pclasmsub looks for a Small subdiagonal element from the botto exit the loop if the growth factor is too Small size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (nb+2*bw)*bw size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (bw*nrhs) the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the Smallest possible condition numbe size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (12*npcol + 3*nb) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (10+2*min(100,nrhs))*npcol+4*nrhs size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b nb*(bwl+bwu)+6*max(bwl,bwu)*max(bwl,bwu) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (max(bwl,bwu)*nrhs) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (12*npcol+3*nb) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b 10*npcol+4*nrhs size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (nb+bwu)*(bwl+bwu)+6*(bwl+bwu)*(bwl+2*bwu) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b nrhs*(nb+2*bwl+4*bwu) r(i) and c(j) are restricted to be between smlnum = Smallest saf factors is not guaranteed to reduce the condition number of Small (local input/local output) double precisio on exit, if log10(large) is sufficiently large, the square pdlaconsb looks for two consecutive Small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a magnitude) endpoint, then it is considered to be sufficiently Small, i.e., converged magnitude) endpoint, then it is considered to be sufficiently Small, i.e., converged look for a single Small subdiagonal element rowcnd (global input) double precision the global ratio of the Smallest r(i) to the largest r(i) scond (global input) double precision ratio of the Smallest sr(i) (respectively sc(j)) to th and ja <= j <= ja+n-1. pdlasmsub looks for a Small subdiagonal element from the botto size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (nb+2*bw)*bw size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (bw*nrhs) the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the Smallest possible condition numbe size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (12*npcol + 3*nb) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (10+2*min(100,nrhs))*npcol+4*nrhs split-off block (see iblock, isplit) and
ordered from Smallest to largest withi
= 'e': ("entire matrix")
il (global input) integer if range='i', the index (from Smallest to largest) of th not referenced if range = 'a' or 'v'. il (global input) integer if range='i', the index (from Smallest to largest) of th not referenced if range = 'a' or 'v'. pdsyntrd is faster than pdsytrd on almost all matrices, particularly Small ones (i.e. n < 500 * sqrt(p) ), provided tha size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b nb*(bwl+bwu)+6*max(bwl,bwu)*max(bwl,bwu) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (max(bwl,bwu)*nrhs) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (12*npcol+3*nb) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b 10*npcol+4*nrhs size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (nb+bwu)*(bwl+bwu)+6*(bwl+bwu)*(bwl+2*bwu) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b nrhs*(nb+2*bwl+4*bwu) r(i) and c(j) are restricted to be between smlnum = Smallest saf factors is not guaranteed to reduce the condition number of Small (local input/local output) rea on exit, if log10(large) is sufficiently large, the square pslaconsb looks for two consecutive Small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a magnitude) endpoint, then it is considered to be sufficiently Small, i.e., converged magnitude) endpoint, then it is considered to be sufficiently Small, i.e., converged look for a single Small subdiagonal element rowcnd (global input) real the global ratio of the Smallest r(i) to the largest r(i) scond (global input) real ratio of the Smallest sr(i) (respectively sc(j)) to th and ja <= j <= ja+n-1. pslasmsub looks for a Small subdiagonal element from the botto size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (nb+2*bw)*bw size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (bw*nrhs) the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the Smallest possible condition numbe size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (12*npcol + 3*nb) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (10+2*min(100,nrhs))*npcol+4*nrhs split-off block (see iblock, isplit) and
ordered from Smallest to largest withi
= 'e': ("entire matrix")
il (global input) integer if range='i', the index (from Smallest to largest) of th not referenced if range = 'a' or 'v'. il (global input) integer if range='i', the index (from Smallest to largest) of th not referenced if range = 'a' or 'v'. pssyntrd is faster than pssytrd on almost all matrices, particularly Small ones (i.e. n < 500 * sqrt(p) ), provided tha size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b nb*(bwl+bwu)+6*max(bwl,bwu)*max(bwl,bwu) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (max(bwl,bwu)*nrhs) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (12*npcol+3*nb) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b 10*npcol+4*nrhs size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (nb+bwu)*(bwl+bwu)+6*(bwl+bwu)*(bwl+2*bwu) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b nrhs*(nb+2*bwl+4*bwu) r(i) and c(j) are restricted to be between smlnum = Smallest saf factors is not guaranteed to reduce the condition number of il (global input) integer if range='i', the index (from Smallest to largest) of th not referenced if range = 'a' or 'v'. il (global input) integer if range='i', the index (from Smallest to largest) of th not referenced if range = 'a' or 'v'. pzhentrd is faster than pzhetrd on almost all matrices, particularly Small ones (i.e. n < 500 * sqrt(p) ), provided tha pzlaconsb looks for two consecutive Small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a look for a single Small subdiagonal element rowcnd (global input) double precision the global ratio of the Smallest r(i) to the largest r(i) scond (global input) double precision ratio of the Smallest sr(i) (respectively sc(j)) to th and ja <= j <= ja+n-1. pzlasmsub looks for a Small subdiagonal element from the botto exit the loop if the growth factor is too Small size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (nb+2*bw)*bw size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (bw*nrhs) the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the Smallest possible condition numbe size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (12*npcol + 3*nb) size of user-input workspace work. if lwork is too Small, the minimal acceptable size will b (10+2*min(100,nrhs))*npcol+4*nrhs slamsh sends multiple shifts through a Small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges if eigenvalues j and j-1 are too close, add a relatively Small perturbation for each block, according to whether top or bottom diagonal element is Smaller look for a single Small subdiagonal element zlamsh sends multiple shifts through a Small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges look for Small superdiagonal element |
| SMALLA SMALLA "congested." as a remedy, when we first hit a border, a 6x6 *local* matrix is generated on one node (called SMALLA) an passed back and everything stays a lot simpler. "congested." as a remedy, when we first hit a border, a 6x6 *local* matrix is generated on one node (called SMALLA) an passed back and everything stays a lot simpler. "congested." as a remedy, when we first hit a border, a 6x6 *local* matrix is generated on one node (called SMALLA) an passed back and everything stays a lot simpler. "congested." as a remedy, when we first hit a border, a 6x6 *local* matrix is generated on one node (called SMALLA) an passed back and everything stays a lot simpler. |
| smaller smaller for each block, according to whether top or bottom diagonal element is smaller zero out space in case result is smaller than storage bloc orthogonality is similar to that obtained from cstein2). note : lwork must be no smaller than and should have the same input value on all processes. zero out space in case result is smaller than storage bloc than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest accuracy, it should not be much smaller in absolute value, and for greatest accuracy, it should not be much smaller than that e (global input) double precision array, dimension (n-1) orthogonality is similar to that obtained from dstein2). note : lwork must be no smaller than and should have the same input value on all processes. zero out space in case result is smaller than storage bloc than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest accuracy, it should not be much smaller than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest accuracy, it should not be much smaller in absolute value, and for greatest accuracy, it should not be much smaller than that e (global input) real array, dimension (n-1) orthogonality is similar to that obtained from sstein2). note : lwork must be no smaller than and should have the same input value on all processes. zero out space in case result is smaller than storage bloc orthogonality is similar to that obtained from zstein2). note : lwork must be no smaller than and should have the same input value on all processes. for each block, according to whether top or bottom diagonal element is smaller |
| smallest smallest r(i) and c(j) are restricted to be between smlnum = smallest saf factors is not guaranteed to reduce the condition number of locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). the componentwise relative backward error of each solution vector x(j) (i.e., the smallest relative change i b(ib:ib+n-1,jb:jb+nrhs-1) that makes x(j) an exact solution). il (global input) integer if range='i', the index (from smallest to largest) of th not referenced if range = 'a' or 'v'. il (global input) integer if range='i', the index (from smallest to largest) of th not referenced if range = 'a' or 'v'. rowcnd (global input) real the global ratio of the smallest r(i) to the largest r(i) scond (global input) real ratio of the smallest sr(i) (respectively sc(j)) to th and ja <= j <= ja+n-1. the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). the componentwise relative backward error of each solution vector x(j) (i.e., the smallest relative change i eigenvalues should be grouped by split-off block and ordered from smallest to largest within the block (the output arra array should be replicated on all processes. locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). r(i) and c(j) are restricted to be between smlnum = smallest saf factors is not guaranteed to reduce the condition number of locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). the componentwise relative backward error of each solution vector x(j) (i.e., the smallest relative change i b(ib:ib+n-1,jb:jb+nrhs-1) that makes x(j) an exact solution). least max_j |e(j)^2| *safe_min, and at least safe_min, where safe_min is at least the smallest number that can divide 1. see pdlapdct for the "paranoid" implementation of the sturm least max_j |e(j)^2| *safe_min, and at least safe_min, where safe_min is at least the smallest number that can divide 1. rowcnd (global input) double precision the global ratio of the smallest r(i) to the largest r(i) scond (global input) double precision ratio of the smallest sr(i) (respectively sc(j)) to th and ja <= j <= ja+n-1. the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). the componentwise relative backward error of each solution vector x(j) (i.e., the smallest relative change i split-off block (see iblock, isplit) and
ordered from smallest to largest withi
= 'e': ("entire matrix")
eigenvalues should be grouped by split-off block and ordered from smallest to largest within the block (the output arra array should be replicated on all processes. il (global input) integer if range='i', the index (from smallest to largest) of th not referenced if range = 'a' or 'v'. il (global input) integer if range='i', the index (from smallest to largest) of th not referenced if range = 'a' or 'v'. locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). r(i) and c(j) are restricted to be between smlnum = smallest saf factors is not guaranteed to reduce the condition number of locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). the componentwise relative backward error of each solution vector x(j) (i.e., the smallest relative change i b(ib:ib+n-1,jb:jb+nrhs-1) that makes x(j) an exact solution). least max_j |e(j)^2| *safe_min, and at least safe_min, where safe_min is at least the smallest number that can divide 1. see pslapdct for the "paranoid" implementation of the sturm least max_j |e(j)^2| *safe_min, and at least safe_min, where safe_min is at least the smallest number that can divide 1. rowcnd (global input) real the global ratio of the smallest r(i) to the largest r(i) scond (global input) real ratio of the smallest sr(i) (respectively sc(j)) to th and ja <= j <= ja+n-1. the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). the componentwise relative backward error of each solution vector x(j) (i.e., the smallest relative change i split-off block (see iblock, isplit) and
ordered from smallest to largest withi
= 'e': ("entire matrix")
eigenvalues should be grouped by split-off block and ordered from smallest to largest within the block (the output arra array should be replicated on all processes. il (global input) integer if range='i', the index (from smallest to largest) of th not referenced if range = 'a' or 'v'. il (global input) integer if range='i', the index (from smallest to largest) of th not referenced if range = 'a' or 'v'. locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). r(i) and c(j) are restricted to be between smlnum = smallest saf factors is not guaranteed to reduce the condition number of locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). the componentwise relative backward error of each solution vector x(j) (i.e., the smallest relative change i b(ib:ib+n-1,jb:jb+nrhs-1) that makes x(j) an exact solution). il (global input) integer if range='i', the index (from smallest to largest) of th not referenced if range = 'a' or 'v'. il (global input) integer if range='i', the index (from smallest to largest) of th not referenced if range = 'a' or 'v'. rowcnd (global input) double precision the global ratio of the smallest r(i) to the largest r(i) scond (global input) double precision ratio of the smallest sr(i) (respectively sc(j)) to th and ja <= j <= ja+n-1. the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). the componentwise relative backward error of each solution vector x(j) (i.e., the smallest relative change i eigenvalues should be grouped by split-off block and ordered from smallest to largest within the block (the output arra array should be replicated on all processes. locc(jb+nrhs-1). the componentwise relative backward error of each solution vector (i.e., the smallest re that makes sub( x ) an exact solution). |
| SMLNUM SMLNUM r(i) and c(j) are restricted to be between SMLNUM = smallest saf factors is not guaranteed to reduce the condition number of SMLNUM (global input) rea unchanged on exit. abs(a(j,j)) > SMLNUM r(i) and c(j) are restricted to be between SMLNUM = smallest saf factors is not guaranteed to reduce the condition number of if ( abs(h10) .le. max(ulp*(abs(h11)+abs(h22)), $ SMLNUM) ) the work(isub+k-2) = zero SMLNUM (global input) double precisio unchanged on exit. r(i) and c(j) are restricted to be between SMLNUM = smallest saf factors is not guaranteed to reduce the condition number of if ( abs(h10) .le. max(ulp*(abs(h11)+abs(h22)), $ SMLNUM) ) the work(isub+k-2) = zero SMLNUM (global input) rea unchanged on exit. r(i) and c(j) are restricted to be between SMLNUM = smallest saf factors is not guaranteed to reduce the condition number of SMLNUM (global input) double precisio unchanged on exit. abs(a(j,j)) > SMLNUM |
| smsq smsq pclassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, pdlassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, pslassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, pzlassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, |
| snip snip this code is basically a parallelization of the following snip this code is basically a parallelization of the following snip this code is basically a parallelization of the following snip this code is basically a parallelization of the following snip |
| Soft Soft a real or complex matrix, with applications to condition estimation", acm trans. math. Soft., vol. 14, no. 4, pp. 381-396, december 1988 ===================================================================== a real or complex matrix, with applications to condition estimation", acm trans. math. Soft., vol. 14, no. 4, pp. 381-396, december 1988 ===================================================================== a real or complex matrix, with applications to condition estimation", acm trans. math. Soft., vol. 14, no. 4, pp. 381-396, december 1988 ===================================================================== a real or complex matrix, with applications to condition estimation", acm trans. math. Soft., vol. 14, no. 4, pp. 381-396, december 1988 ===================================================================== |
| solution solution on entry, the right hand side matrix b. on exit, b is overwritten by the solution matrix x ldb (input) integer on entry, the right hand side matrix b. on exit, the solution matrix x ldb (input) integer on entry, the right hand side matrix b. on exit, b is overwritten by the solution matrix x ldb (input) integer on entry, the right hand side matrix b. on exit, the solution matrix x ldb (input) integer b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, stor b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, stor b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. pcgerfs improves the computed solution to a system of linea the solutions. pcgesv computes the solution to a complex system of linear equation sub( a ) * x = sub( b ), pcgesvx uses the lu factorization to compute the solution to (lld_b,locc(jb+nrhs-1)). on entry, the right hand sides sub( b ). on exit, sub( b ) is overwritten by the solution compute a bound on the computed solution vector to see if th b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, stor
{f_i}^c = {h_i}{{b'}_i}^c
b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste pcporfs improves the computed solution to a system of linea and provides error bounds and backward error estimates for the pcposv computes the solution to a complex system of linear equation sub( a ) * x = sub( b ), pcposvx uses the cholesky factorization a = u**h*u or a = l*l**h to compute the solution to a complex system of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), the local pieces of the right hand sides sub( b ). on exit, this array contains the local pieces of the solution b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, stor
{f_i}^c = {h_i}{{b'}_i}^c
b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste pctrrfs provides error bounds and backward error estimates for the solution to a system of linear equations with a triangula sub( b ). on exit, if info = 0, sub( b ) is overwritten by the solution matrix x ib (global input) integer b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, stor b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, stor b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. pdgerfs improves the computed solution to a system of linea the solutions. pdgesv computes the solution to a real system of linear equation sub( a ) * x = sub( b ), pdgesvx uses the lu factorization to compute the solution to a rea (lld_b,locc(jb+nrhs-1)). on entry, the right hand sides sub( b ). on exit, sub( b ) is overwritten by the solution b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, stor
{f_i}^t = {h_i}{{b'}_i}^t
b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste pdporfs improves the computed solution to a system of linea and provides error bounds and backward error estimates for the pdposv computes the solution to a real system of linear equation sub( a ) * x = sub( b ), pdposvx uses the cholesky factorization a = u**t*u or a = l*l**t to compute the solution to a real system of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), the local pieces of the right hand sides sub( b ). on exit, this array contains the local pieces of the solution b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, stor
{f_i}^t = {h_i}{{b'}_i}^t
b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste the worst machine around. note that this has no effect on the accuracy of the solution ===================================================================== pdtrrfs provides error bounds and backward error estimates for the solution to a system of linear equations with a triangula sub( b ). on exit, if info = 0, sub( b ) is overwritten by the solution matrix x ib (global input) integer b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, stor b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, stor b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. psgerfs improves the computed solution to a system of linea the solutions. psgesv computes the solution to a real system of linear equation sub( a ) * x = sub( b ), psgesvx uses the lu factorization to compute the solution to a rea (lld_b,locc(jb+nrhs-1)). on entry, the right hand sides sub( b ). on exit, sub( b ) is overwritten by the solution b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, stor
{f_i}^t = {h_i}{{b'}_i}^t
b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste psporfs improves the computed solution to a system of linea and provides error bounds and backward error estimates for the psposv computes the solution to a real system of linear equation sub( a ) * x = sub( b ), psposvx uses the cholesky factorization a = u**t*u or a = l*l**t to compute the solution to a real system of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), the local pieces of the right hand sides sub( b ). on exit, this array contains the local pieces of the solution b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, stor
{f_i}^t = {h_i}{{b'}_i}^t
b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste the worst machine around. note that this has no effect on the accuracy of the solution ===================================================================== pstrrfs provides error bounds and backward error estimates for the solution to a system of linear equations with a triangula sub( b ). on exit, if info = 0, sub( b ) is overwritten by the solution matrix x ib (global input) integer b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, stor b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, stor b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. pzgerfs improves the computed solution to a system of linea the solutions. pzgesv computes the solution to a complex system of linear equation sub( a ) * x = sub( b ), pzgesvx uses the lu factorization to compute the solution to (lld_b,locc(jb+nrhs-1)). on entry, the right hand sides sub( b ). on exit, sub( b ) is overwritten by the solution compute a bound on the computed solution vector to see if th b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, stor
{f_i}^c = {h_i}{{b'}_i}^c
b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste pzporfs improves the computed solution to a system of linea and provides error bounds and backward error estimates for the pzposv computes the solution to a complex system of linear equation sub( a ) * x = sub( b ), pzposvx uses the cholesky factorization a = u**h*u or a = l*l**h to compute the solution to a complex system of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), the local pieces of the right hand sides sub( b ). on exit, this array contains the local pieces of the solution b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, stor
{f_i}^c = {h_i}{{b'}_i}^c
b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solution *********************************************** formation and solution of reduced syste pztrrfs provides error bounds and backward error estimates for the solution to a system of linear equations with a triangula sub( b ). on exit, if info = 0, sub( b ) is overwritten by the solution matrix x ib (global input) integer on entry, the right hand side matrix b. on exit, b is overwritten by the solution matrix x ldb (input) integer on entry, the right hand side matrix b. on exit, the solution matrix x ldb (input) integer on entry, the right hand side matrix b. on exit, b is overwritten by the solution matrix x ldb (input) integer on entry, the right hand side matrix b. on exit, the solution matrix x ldb (input) integer |
| solutions solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions equations and provides error bounds and backward error estimates for the solutions notes b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares and provides error bounds and backward error estimates for the solutions notes b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares zero, indicating that the submatrix is singular and the solutions x have not been computed ===================================================================== b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions equations and provides error bounds and backward error estimates for the solutions notes b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares and provides error bounds and backward error estimates for the solutions notes b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares zero, indicating that the submatrix is singular and the solutions x have not been computed ===================================================================== b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions equations and provides error bounds and backward error estimates for the solutions notes b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares and provides error bounds and backward error estimates for the solutions notes b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares zero, indicating that the submatrix is singular and the solutions x have not been computed ===================================================================== b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions equations and provides error bounds and backward error estimates for the solutions notes b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares and provides error bounds and backward error estimates for the solutions notes b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions b(ib:ib+n-1, 1:nrhs). on exit, this contains the local piece of the solutions ****************************** reduced system has been solved, communicate solutions to neares zero, indicating that the submatrix is singular and the solutions x have not been computed ===================================================================== |
| solve solve singular, and division by zero will occur if it is used to solve a system of equations further details singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== cdttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, singular, and division by zero will occur if it is used to solve a system of equations further details singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== ddttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, solve the system lu = pb pcdbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{bu'}_i} = {b_i
pcdbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve pcdtsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular solve {u_i}^c{bl'}_i^c = {bl_i}^
pcdttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve pcgbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) lbwl, lbwu: lower and upper bandwidth of local solve lm is the number of rows which is usually nb except for pcgbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pcgels solves overdetermined or underdetermined complex linea or its conjugate-transpose, using a qr or lq factorization of l and u are stored in sub( a ). the factored form of sub( a ) is then used to solve the system of equations sub( a ) * x = sub( b ) notes is exactly singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== is exactly singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== use the level 2 pblas solve if the reciprocal of the bound o pcpbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{b'}_i}^c = {b_i}^
pcpbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve where u is an upper triangular matrix and l is a lower triangular matrix. the factored form of sub( a ) is then used to solve th pcptsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{b'}_i}^c = {b_i}^
pcpttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve the code robust against possible overflow. but scaling has not yet been implemented in pclattrs which is called by this routine to solve pctrtrs solves a triangular system of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ) or pddbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{bu'}_i} = {b_i
pddbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve pddtsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular solve {u_i}^t{bl'}_i^t = {bl_i}^
pddttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve pdgbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) lbwl, lbwu: lower and upper bandwidth of local solve lm is the number of rows which is usually nb except for pdgbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pdgels solves overdetermined or underdetermined real linea or its transpose, using a qr or lq factorization of sub( a ). it is l and u are stored in sub( a ). the factored form of sub( a ) is then used to solve the system of equations sub( a ) * x = sub( b ) notes is exactly singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== is exactly singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== pdpbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{b'}_i}^t = {b_i}^
pdpbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve where u is an upper triangular matrix and l is a lower triangular matrix. the factored form of sub( a ) is then used to solve th pdptsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{b'}_i}^t = {b_i}^
pdpttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve pdtrtrs solves a triangular system of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ), psdbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{bu'}_i} = {b_i
psdbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve psdtsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular solve {u_i}^t{bl'}_i^t = {bl_i}^
psdttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve psgbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) lbwl, lbwu: lower and upper bandwidth of local solve lm is the number of rows which is usually nb except for psgbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) psgels solves overdetermined or underdetermined real linea or its transpose, using a qr or lq factorization of sub( a ). it is l and u are stored in sub( a ). the factored form of sub( a ) is then used to solve the system of equations sub( a ) * x = sub( b ) notes is exactly singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== is exactly singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== pspbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{b'}_i}^t = {b_i}^
pspbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve where u is an upper triangular matrix and l is a lower triangular matrix. the factored form of sub( a ) is then used to solve th psptsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{b'}_i}^t = {b_i}^
pspttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve pstrtrs solves a triangular system of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ), pzdbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{bu'}_i} = {b_i
pzdbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve pzdtsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular solve {u_i}^c{bl'}_i^c = {bl_i}^
pzdttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve pzgbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) lbwl, lbwu: lower and upper bandwidth of local solve lm is the number of rows which is usually nb except for pzgbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pzgels solves overdetermined or underdetermined complex linea or its conjugate-transpose, using a qr or lq factorization of l and u are stored in sub( a ). the factored form of sub( a ) is then used to solve the system of equations sub( a ) * x = sub( b ) notes is exactly singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== is exactly singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== use the level 2 pblas solve if the reciprocal of the bound o pzpbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{b'}_i}^c = {b_i}^
pzpbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve where u is an upper triangular matrix and l is a lower triangular matrix. the factored form of sub( a ) is then used to solve th pzptsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular system solve {l_i}{{b'}_i}^c = {b_i}^
pzpttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) frontsolve the code robust against possible overflow. but scaling has not yet been implemented in pzlattrs which is called by this routine to solve pztrtrs solves a triangular system of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ) or singular, and division by zero will occur if it is used to solve a system of equations further details singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== sdttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, solve the system lu = pb singular, and division by zero will occur if it is used to solve a system of equations further details singular, and division by zero will occur if it is used to solve a system of equations ===================================================================== zdttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, |
| solved solved pcdbtrf and this is stored in af. if a linear system is to be solved using pcdbtrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares pcdttrf and this is stored in af. if a linear system is to be solved using pcdttrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares pcgbtrf and this is stored in af. if a linear system is to be solved using pcgbtrs after the factorizatio 4. the system of equations is solved for x using the factored for ibtype (global input) integer specifies the problem type to be solved = 2: sub( a )*sub( b )*x = (lambda)*x pcpbtrf and this is stored in af. if a linear system is to be solved using pcpbtrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares 4. the system of equations is solved for x using the factored for pcpttrf and this is stored in af. if a linear system is to be solved using pcpttrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares pddbtrf and this is stored in af. if a linear system is to be solved using pddbtrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares pddttrf and this is stored in af. if a linear system is to be solved using pddttrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares pdgbtrf and this is stored in af. if a linear system is to be solved using pdgbtrs after the factorizatio 4. the system of equations is solved for x using the factored for pdpbtrf and this is stored in af. if a linear system is to be solved using pdpbtrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares 4. the system of equations is solved for x using the factored for pdpttrf and this is stored in af. if a linear system is to be solved using pdpttrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares ibtype (global input) integer specifies the problem type to be solved = 2: sub( a )*sub( b )*x = (lambda)*x psdbtrf and this is stored in af. if a linear system is to be solved using psdbtrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares psdttrf and this is stored in af. if a linear system is to be solved using psdttrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares psgbtrf and this is stored in af. if a linear system is to be solved using psgbtrs after the factorizatio 4. the system of equations is solved for x using the factored for pspbtrf and this is stored in af. if a linear system is to be solved using pspbtrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares 4. the system of equations is solved for x using the factored for pspttrf and this is stored in af. if a linear system is to be solved using pspttrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares ibtype (global input) integer specifies the problem type to be solved = 2: sub( a )*sub( b )*x = (lambda)*x pzdbtrf and this is stored in af. if a linear system is to be solved using pzdbtrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares pzdttrf and this is stored in af. if a linear system is to be solved using pzdttrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares pzgbtrf and this is stored in af. if a linear system is to be solved using pzgbtrs after the factorizatio 4. the system of equations is solved for x using the factored for ibtype (global input) integer specifies the problem type to be solved = 2: sub( a )*sub( b )*x = (lambda)*x pzpbtrf and this is stored in af. if a linear system is to be solved using pzpbtrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares 4. the system of equations is solved for x using the factored for pzpttrf and this is stored in af. if a linear system is to be solved using pzpttrs after the factorizatio ****************************** reduced system has been solved, communicate solutions to neares |
| solver solver lbwl, lbwu: lower and upper bandwidth of local solver lm is the number of rows which is usually nb except for lbwl, lbwu: lower and upper bandwidth of local solver lm is the number of rows which is usually nb except for lbwl, lbwu: lower and upper bandwidth of local solver lm is the number of rows which is usually nb except for lbwl, lbwu: lower and upper bandwidth of local solver lm is the number of rows which is usually nb except for |
| solves solves cdttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, cpttrsv solves one of the triangular system u * x = b, or u**h * x = b, ddttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, dpttrsv solves one of the triangular system where l is the cholesky factor of a hermitian positive pcdbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pcdbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pcdtsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pcdttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pcgbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pcgbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pcgels solves overdetermined or underdetermined complex linea or its conjugate-transpose, using a qr or lq factorization of premultiplied by diag(c) (if trans = 'n') or diag(r) (if trans = 't' or 'c') so that it solves the original syste pcgetrs solves a system of distributed linear equation op( sub( a ) ) * x = sub( b ) rank 2k updates, which are faster and more scalable than triangular solves (the basis of pchengst) pchengst calls pchegst when uplo='u', hence pchengst provides pcpbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pcpbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) 6. if equilibration was used, the matrix x is premultiplied by diag(sr) so that it solves the original system befor pcpotrs solves a system of linear equation sub( a ) * x = sub( b ) pcptsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pcpttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pctrtrs solves a triangular system of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ) or pddbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pddbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pddtsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pddttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pdgbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pdgbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pdgels solves overdetermined or underdetermined real linea or its transpose, using a qr or lq factorization of sub( a ). it is premultiplied by diag(c) (if trans = 'n') or diag(r) (if trans = 't' or 'c') so that it solves the original syste pdgetrs solves a system of distributed linear equation op( sub( a ) ) * x = sub( b ) pdpbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pdpbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) 6. if equilibration was used, the matrix x is premultiplied by diag(sr) so that it solves the original system befor pdpotrs solves a system of linear equation sub( a ) * x = sub( b ) pdptsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pdpttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) rank 2k updates, which are faster and more scalable than triangular solves (the basis of pdsyngst) pdsyngst calls pdhegst when uplo='u', hence pdhengst provides pdtrtrs solves a triangular system of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ), psdbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) psdbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) psdtsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) psdttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) psgbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) psgbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) psgels solves overdetermined or underdetermined real linea or its transpose, using a qr or lq factorization of sub( a ). it is premultiplied by diag(c) (if trans = 'n') or diag(r) (if trans = 't' or 'c') so that it solves the original syste psgetrs solves a system of distributed linear equation op( sub( a ) ) * x = sub( b ) pspbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pspbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) 6. if equilibration was used, the matrix x is premultiplied by diag(sr) so that it solves the original system befor pspotrs solves a system of linear equation sub( a ) * x = sub( b ) psptsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pspttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) rank 2k updates, which are faster and more scalable than triangular solves (the basis of pssyngst) pssyngst calls pshegst when uplo='u', hence pshengst provides pstrtrs solves a triangular system of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ), pzdbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pzdbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pzdtsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pzdttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pzgbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pzgbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pzgels solves overdetermined or underdetermined complex linea or its conjugate-transpose, using a qr or lq factorization of premultiplied by diag(c) (if trans = 'n') or diag(r) (if trans = 't' or 'c') so that it solves the original syste pzgetrs solves a system of distributed linear equation op( sub( a ) ) * x = sub( b ) rank 2k updates, which are faster and more scalable than triangular solves (the basis of pzhengst) pzhengst calls pzhegst when uplo='u', hence pzhengst provides pzpbsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pzpbtrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) 6. if equilibration was used, the matrix x is premultiplied by diag(sr) so that it solves the original system befor pzpotrs solves a system of linear equation sub( a ) * x = sub( b ) pzptsv solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pzpttrs solves a system of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pztrtrs solves a triangular system of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ) or sdttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, spttrsv solves one of the triangular system where l is the cholesky factor of a hermitian positive zdttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, zpttrsv solves one of the triangular system u * x = b, or u**h * x = b, |
| solving solving the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted inva by solving the system inva*l = inv(u) for inva notes the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted inva by solving the system inva*l = inv(u) for inva notes the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted inva by solving the system inva*l = inv(u) for inva notes the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted inva by solving the system inva*l = inv(u) for inva notes the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear system currently, only algorithms designed for the case n/p >> bw are |
| some some the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrices sub( a ) and sub( b ) must verify some the distributed submatrices sub( a ) and sub( b ) must verify some the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices sub( a ), sub( z ) must verify some alignment properties, namely the following expressio ( mb_a.eq.nb_a.eq.mb_z.eq.nb_z .and. iroffa.eq.icoffa .and. if this routine returns with ((mod(info,2).ne.0) .or.
(mod(info/8,2).ne.0)), indicating that some eigenvalues o
2*pslamch('s').
if this routine returns with ((mod(info,2).ne.0) .or.
(mod(info/8,2).ne.0)), indicating that some eigenvalues o
2*pslamch('s').
the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa .and. iroffa.eq.0 ) with the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) with the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa .and. iroffa.eq.0 ) with column (i.e. mycol .eq. curcol) they are the same. however, on some processors, a( lii, lij ) points to an elemen finishing up. even if rotn=1, in order to minimize border communication sometimes k1(ki)=hbl-2 & k2(ki)=hbl-1 so bot the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. pctrevc computes some or all of the right and/or left eigenvectors o the solution matrix x must be computed by pctrtrs or some othe refinement because doing so cannot improve the backward error. the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrices sub( a ) and sub( b ) must verify some the distributed submatrices sub( a ) and sub( b ) must verify some dlahqr used to have a single row application and a single column application to h. here we do something a littl parts: the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. note: in the (theoretically impossible) event that bisection does not converge for some or all eigenvalues, info is se negative block number. the distributed submatrices a(ia:*, ja:*) and z(iz:iz+m-1,jz:jz+n-1) must verify some alignment properties, namely the followin the distributed submatrices sub( a ), sub( z ) must verify some alignment properties, namely the following expressio ( mb_a.eq.nb_a.eq.mb_z.eq.nb_z .and. iroffa.eq.icoffa .and. if this routine returns with ((mod(info,2).ne.0) .or.
(mod(info/8,2).ne.0)), indicating that some eigenvalues o
2*pdlamch('s').
if this routine returns with ((mod(info,2).ne.0) .or.
(mod(info/8,2).ne.0)), indicating that some eigenvalues o
2*pdlamch('s').
the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa .and. iroffa.eq.0 ) with the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) with the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa .and. iroffa.eq.0 ) with column (i.e. mycol .eq. curcol) they are the same. however, on some processors, a( lii, lij ) points to an elemen the solution matrix x must be computed by pdtrtrs or some othe refinement because doing so cannot improve the backward error. on all processors and hence pjlaenv will return the same value to all procesors (i.e. global output). however some on each processor and hence pjlaenv can return different the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrices sub( a ) and sub( b ) must verify some the distributed submatrices sub( a ) and sub( b ) must verify some slahqr used to have a single row application and a single column application to h. here we do something a littl parts: the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. note: in the (theoretically impossible) event that bisection does not converge for some or all eigenvalues, info is se negative block number. the distributed submatrices a(ia:*, ja:*) and z(iz:iz+m-1,jz:jz+n-1) must verify some alignment properties, namely the followin the distributed submatrices sub( a ), sub( z ) must verify some alignment properties, namely the following expressio ( mb_a.eq.nb_a.eq.mb_z.eq.nb_z .and. iroffa.eq.icoffa .and. if this routine returns with ((mod(info,2).ne.0) .or.
(mod(info/8,2).ne.0)), indicating that some eigenvalues o
2*pslamch('s').
if this routine returns with ((mod(info,2).ne.0) .or.
(mod(info/8,2).ne.0)), indicating that some eigenvalues o
2*pslamch('s').
the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa .and. iroffa.eq.0 ) with the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) with the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa .and. iroffa.eq.0 ) with column (i.e. mycol .eq. curcol) they are the same. however, on some processors, a( lii, lij ) points to an elemen the solution matrix x must be computed by pstrtrs or some othe refinement because doing so cannot improve the backward error. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) the distributed submatrices sub( a ) and sub( b ) must verify some the distributed submatrices sub( a ) and sub( b ) must verify some the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices sub( a ), sub( z ) must verify some alignment properties, namely the following expressio ( mb_a.eq.nb_a.eq.mb_z.eq.nb_z .and. iroffa.eq.icoffa .and. if this routine returns with ((mod(info,2).ne.0) .or.
(mod(info/8,2).ne.0)), indicating that some eigenvalues o
2*pdlamch('s').
if this routine returns with ((mod(info,2).ne.0) .or.
(mod(info/8,2).ne.0)), indicating that some eigenvalues o
2*pdlamch('s').
the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa .and. iroffa.eq.0 ) with the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa ) with the distributed submatrix sub( a ) must verify some alignment proper ( mb_a.eq.nb_a .and. iroffa.eq.icoffa .and. iroffa.eq.0 ) with column (i.e. mycol .eq. curcol) they are the same. however, on some processors, a( lii, lij ) points to an elemen finishing up. even if rotn=1, in order to minimize border communication sometimes k1(ki)=hbl-2 & k2(ki)=hbl-1 so bot the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. pztrevc computes some or all of the right and/or left eigenvectors o the solution matrix x must be computed by pztrtrs or some othe refinement because doing so cannot improve the backward error. the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1) must verify some alignment properties, namely the followin |
| something something clahqr used to have a single row application and a single column application to h. here we do something a littl parts: dlahqr used to have a single row application and a single column application to h. here we do something a littl parts: slahqr used to have a single row application and a single column application to h. here we do something a littl parts: zlahqr used to have a single row application and a single column application to h. here we do something a littl parts: |
| sometimes sometimes finishing up. even if rotn=1, in order to minimize border communication sometimes k1(ki)=hbl-2 & k2(ki)=hbl-1 so bot finishing up. even if rotn=1, in order to minimize border communication sometimes k1(ki)=hbl-2 & k2(ki)=hbl-1 so bot |
| SONEST SONEST the serial version clacon has been contributed by nick higham, university of manchester. it was originally named SONEST, date the serial version dlacon has been contributed by nick higham, university of manchester. it was originally named SONEST, date the serial version slacon has been contributed by nick higham, university of manchester. it was originally named SONEST, date the serial version zlacon has been contributed by nick higham, university of manchester. it was originally named SONEST, date |
| sort sort do insertion sort on d( start:endd do insertion sort on d( start:endd pdlaed2 sorts the two sets of eigenvalues together into a singl there are two ways in which deflation can occur: when two or more on exit, d contains the trailing (n-k) updated eigenvalues (those which were deflated) sorted into increasing order drow (global input) integer sort the eigenpairs so that they are in twos for doubl pdlasrt sort the numbers in d in increasing order and th pslaed2 sorts the two sets of eigenvalues together into a singl there are two ways in which deflation can occur: when two or more on exit, d contains the trailing (n-k) updated eigenvalues (those which were deflated) sorted into increasing order drow (global input) integer sort the eigenpairs so that they are in twos for doubl pslasrt sort the numbers in d in increasing order and th do insertion sort on d( start:endd do insertion sort on d( start:endd |
| sorted sorted s (global output) real array, dimension size the singular values of a, sorted so that s(i) >= s(i+1) u (local output) complex array, local dimension pclaevswp moves the eigenvectors (potentially unsorted) fro array, sorted so that the corresponding eigenvalues are sorted. s (global output) double precision array, dimension size the singular values of a, sorted so that s(i) >= s(i+1) u (local output) double precision array, local dimension pdlaed2 sorts the two sets of eigenvalues together into a single sorted set. then it tries to deflate the size of the problem eigenvalues are close together or if there is a tiny entry in the on exit, d contains the trailing (n-k) updated eigenvalues (those which were deflated) sorted into increasing order drow (global input) integer pdlaevswp moves the eigenvectors (potentially unsorted) fro array, sorted so that the corresponding eigenvalues are sorted. d (global input/output) double precision array, dimmension (n) on exit, the number in d are sorted in increasing order q (local input) double precision pointer into the local memory s (global output) real array, dimension size the singular values of a, sorted so that s(i) >= s(i+1) u (local output) real array, local dimension pslaed2 sorts the two sets of eigenvalues together into a single sorted set. then it tries to deflate the size of the problem eigenvalues are close together or if there is a tiny entry in the on exit, d contains the trailing (n-k) updated eigenvalues (those which were deflated) sorted into increasing order drow (global input) integer pslaevswp moves the eigenvectors (potentially unsorted) fro array, sorted so that the corresponding eigenvalues are sorted. d (global input/output) real array, dimmension (n) on exit, the number in d are sorted in increasing order q (local input) real pointer into the local memory s (global output) double precision array, dimension size the singular values of a, sorted so that s(i) >= s(i+1) u (local output) complex*16 array, local dimension pzlaevswp moves the eigenvectors (potentially unsorted) fro array, sorted so that the corresponding eigenvalues are sorted. |
| sorting sorting key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th sort the eigenpairs so that they are in twos for double shifts. only call if several need sorting key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th sort the eigenpairs so that they are in twos for double shifts. only call if several need sorting key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th |
| sorts sorts dlasorte sorts eigenpairs so that real eigenpairs are together an since every 2nd subdiagonal is guaranteed to be zero. pdlaed2 sorts the two sets of eigenvalues together into a singl there are two ways in which deflation can occur: when two or more pslaed2 sorts the two sets of eigenvalues together into a singl there are two ways in which deflation can occur: when two or more slasorte sorts eigenpairs so that real eigenpairs are together an since every 2nd subdiagonal is guaranteed to be zero. |
| Source Source Source processor must be the sam Source processor must be the sam if ii=-1,jj=-1, then all nodes receive the data if rev<>0, then ii is the Source row index for the node(s Source processor must be the sam Source processor must be the sam Source processor must be the sam Source processor must be the sam if ii=-1,jj=-1, then all nodes receive the data if rev<>0, then ii is the Source row index for the node(s Source processor must be the sam Source processor must be the sam Source processor must be the sam Source processor must be the sam if ii=-1,jj=-1, then all nodes receive the data if rev<>0, then ii is the Source row index for the node(s Source processor must be the sam Source processor must be the sam Source processor must be the sam Source processor must be the sam if ii=-1,jj=-1, then all nodes receive the data if rev<>0, then ii is the Source row index for the node(s Source processor must be the sam Source processor must be the sam |
| space space work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) complex array, dimension laf. auxiliary fillin space pcdbtrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) complex array, dimension laf. auxiliary fillin space pcdttrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) complex array, dimension laf. auxiliary fillin space pcgbtrf and this is stored in af. if a linear system a (local input/workspace) block cyclic complex array local dimension ( lld_a, locc(ja+n-1) ) if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pchegvx is not able to detect thi requested, the user must supply both sufficient work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) complex array, dimension laf. auxiliary fillin space pcpbtrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) complex array, dimension laf. auxiliary fillin space pcpttrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be contained in one and only one process memory space (local operation) notes work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) double precision array, dimension laf. auxiliary fillin space pddbtrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) double precision array, dimension laf. auxiliary fillin space pddttrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) double precision array, dimension laf. auxiliary fillin space pdgbtrf and this is stored in af. if a linear system work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) double precision array, dimension laf. auxiliary fillin space pdpbtrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) double precision array, dimension laf. auxiliary fillin space pdpttrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int a (local input/workspace) block cyclic double precision array local dimension ( lld_a, locc(ja+n-1) ) if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pdsygvx is not able to detect thi requested, the user must supply both sufficient block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be contained in one and only one process memory space (local operation) notes work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) real array, dimension laf. auxiliary fillin space psdbtrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) real array, dimension laf. auxiliary fillin space psdttrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) real array, dimension laf. auxiliary fillin space psgbtrf and this is stored in af. if a linear system work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) real array, dimension laf. auxiliary fillin space pspbtrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) real array, dimension laf. auxiliary fillin space pspttrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int a (local input/workspace) block cyclic real array local dimension ( lld_a, locc(ja+n-1) ) if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pssygvx is not able to detect thi requested, the user must supply both sufficient block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be contained in one and only one process memory space (local operation) notes work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) complex*16 array, dimension laf. auxiliary fillin space pzdbtrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) complex*16 array, dimension laf. auxiliary fillin space pzdttrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) complex*16 array, dimension laf. auxiliary fillin space pzgbtrf and this is stored in af. if a linear system a (local input/workspace) block cyclic complex*16 array local dimension ( lld_a, locc(ja+n-1) ) if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pzhegvx is not able to detect thi requested, the user must supply both sufficient work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) complex*16 array, dimension laf. auxiliary fillin space pzpbtrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int work (local workspace/local output be overwritten in between calls to routines. work must be adjust addressing into matrix space to properly get int af (local output) complex*16 array, dimension laf. auxiliary fillin space pzpttrf and this is stored in af. if a linear system adjust addressing into matrix space to properly get int block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be contained in one and only one process memory space (local operation) notes |
| spacing spacing save the shift to check eigenvalue spacing at nex the clusters with the smallest spacing between the eigenvalues requested, no computation is performed and info=-25 the clusters with the smallest spacing between the eigenvalues requested, no computation is performed and info=-25 the clusters with the smallest spacing between the eigenvalues requested, no computation is performed and info=-23 the clusters with the smallest spacing between the eigenvalues requested, no computation is performed and info=-23 the clusters with the smallest spacing between the eigenvalues requested, no computation is performed and info=-23 the clusters with the smallest spacing between the eigenvalues requested, no computation is performed and info=-23 the clusters with the smallest spacing between the eigenvalues requested, no computation is performed and info=-25 the clusters with the smallest spacing between the eigenvalues requested, no computation is performed and info=-25 save the shift to check eigenvalue spacing at nex |
| spans spans blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: blocksize cannot be too small: if the matrix spans more than one processor, the followin must hold: |
| sparsely sparsely pjlaenv is patterned after ilaenv and keeps the same interface in anticipation of future needs, even though pjlaenv is only sparsely data layout blocking factor as the algorithmic blocking factor - |
| special special the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, the best algorithm for solving banded and tridiagonal linear systems depends on a variety of parameters, especially the bandwidth implemented. these go by many names, including divide and conquer, |
| specific specific argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin argument checking that is specific to divide & conquer routin |
| specified specified claref applies one or several householder reflectors of size 3 to one or two matrices (if column is specified) on either thei dlaref applies one or several householder reflectors of size 3 to one or two matrices (if column is specified) on either thei the entire submatrix that is copied gets placed on one node or more. the receiving node can be specified precisely, or all node 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. = 's': compute selected right and/or left eigenvectors, specified by the logical array select select (global input) logical array, dimension (n) the entire submatrix that is copied gets placed on one node or more. the receiving node can be specified precisely, or all node the counts at the endpoints are identical to the counts specified by nval ( see nval ) then the interval i 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. trans = 't', and diag = 'n' for a triangular routine would be specified as opts = 'utn' n1 (global input) integer the entire submatrix that is copied gets placed on one node or more. the receiving node can be specified precisely, or all node the counts at the endpoints are identical to the counts specified by nval ( see nval ) then the interval i 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. the entire submatrix that is copied gets placed on one node or more. the receiving node can be specified precisely, or all node 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. = 's': compute selected right and/or left eigenvectors, specified by the logical array select select (global input) logical array, dimension (n) slaref applies one or several householder reflectors of size 3 to one or two matrices (if column is specified) on either thei zlaref applies one or several householder reflectors of size 3 to one or two matrices (if column is specified) on either thei |
| Specifies Specifies uplo (input) character*1 Specifies whether to solve with l or u trans (input) character istart (global input) integer Specifies the "number" of the first reflector. this i istart is ignored if block is .false.. uplo (input) character*1 Specifies whether the superdiagonal or the subdiagona factorization: uplo - character*1. on entry, uplo Specifies whether the matrix is an upper o uplo (input) character*1 Specifies whether to solve with l or u trans (input) character istart (global input) integer Specifies the "number" of the first reflector. this i istart is ignored if block is .false.. trans (input) character Specifies the form of the system of equations = 't': l**t * x = b (transpose) uplo - character*1. on entry, uplo Specifies whether the matrix is an upper o norm (global input) character Specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm trans (global input) character*1 Specifies the form of the system of equations = 't': sub( a )**t * sub( x ) = sub( b ) (transpose) jobu (global input) character*1 Specifies options for computing u vectors) are returned in the array u; fact (global input) character Specifies whether or not the factored form of the matri whether the matrix a(ia:ia+n-1,ja:ja+n-1) should be trans (global input) character Specifies the form of the system of equations = 't': sub( a )**t * x = sub( b ) (transpose) jobz (global input) character*1 Specifies whether or not to compute the eigenvectors = 'v': compute eigenvalues and eigenvectors. uplo (global input) character*1 Specifies whether the upper or lower triangular part of th = 'u': upper triangular jobz (global input) character*1 Specifies whether or not to compute the eigenvectors = 'v': compute eigenvalues and eigenvectors. ibtype (global input) integer Specifies the problem type to be solved = 2: sub( a )*sub( b )*x = (lambda)*x uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is copied; the strictly uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is copied; the strictly norm (global input) character Specifies the value to be returned in pclange as describe direc (global input) character*1 Specifies in which order the permutation is applied computes p*sub( a ). direc (global input) character Specifies in which order the permutation is applied computes p * sub( a ); equed (global output) character Specifies the form of equilibration that was done = 'r': row equilibration, i.e., sub( a ) has been pre- uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular direct (global input) character*1 Specifies the order in which the elementary reflectors ar = 'f': h = h(1) h(2) . . . h(k) (forward) direct (global input) character Specifies the order in which the elementary reflectors ar = 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet) is done without over/underflow as long as the final result cto * a(i,j) / cfrom does not over/underflow. type Specifies tha hessenberg. uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is set; the strictly lower uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is set; the strictly lower direc (global input) character Specifies in which order the permutation is applied = 'b' (backward) uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character*1 Specifies whether the triangular factor stored in the matri = 'u': upper triangular, uplo (global input) character*1 Specifies whether the triangular factor stored in th = 'u': upper triangular uplo (global input) character Specifies whether the factor stored i = 'u': upper triangular uplo (global input) character*1 Specifies whether the upper or lower triangular part of th = 'u': upper triangular fact (global input) character Specifies whether or not the factored form of the matrix a i equilibrated before it is factored. orfac (global input) real orfac Specifies which eigenvectors should be orthogonalized orfac*||t|| of each other are to be orthogonalized. norm (global input) character Specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm; select (global input) logical array, dimension (n) if howmny = 's', select Specifies the eigenvectors to b if howmny = 'a' or 'b', select is not referenced. trans (global input) character*1 Specifies the form of the system of equations = 't': sub( a )**t * sub( x ) = sub( b ) (transpose) uplo (global input) character Specifies whether the distributed matrix sub( a ) is uppe = 'u': upper triangular, trans (global input) character Specifies the form of the system of equations = 't': solve sub( a )**t * x = sub( b ) (transpose) norm (global input) character Specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm trans (global input) character*1 Specifies the form of the system of equations = 't': sub( a )**t * sub( x ) = sub( b ) (transpose) jobu (global input) character*1 Specifies options for computing u vectors) are returned in the array u; fact (global input) character Specifies whether or not the factored form of the matri whether the matrix a(ia:ia+n-1,ja:ja+n-1) should be trans (global input) character Specifies the form of the system of equations = 't': sub( a )**t * x = sub( b ) (transpose) uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is copied; the strictly uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is copied; the strictly ijob (input) integer Specifies the computation done by pdlaeb endpoints of the interval. ijob (input) integer Specifies the criterion for "convergence" of an interval reltol times the larger (in magnitude) endpoint, then cmach (global input) character*1 Specifies the value to be returned by pdlamch = 's' or 's , pdlamch := sfmin norm (global input) character Specifies the value to be returned in pdlange as describe direc (global input) character*1 Specifies in which order the permutation is applied computes p*sub( a ). direc (global input) character Specifies in which order the permutation is applied computes p * sub( a ); equed (global output) character Specifies the form of equilibration that was done = 'r': row equilibration, i.e., sub( a ) has been pre- uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular direct (global input) character*1 Specifies the order in which the elementary reflectors ar = 'f': h = h(1) h(2) . . . h(k) (forward) direct (global input) character Specifies the order in which the elementary reflectors ar = 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet) is done without over/underflow as long as the final result cto * a(i,j) / cfrom does not over/underflow. type Specifies tha hessenberg. uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is set; the strictly lower uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is set; the strictly lower direc (global input) character Specifies in which order the permutation is applied = 'b' (backward) uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character*1 Specifies whether the triangular factor stored in the matri = 'u': upper triangular, uplo (global input) character*1 Specifies whether the triangular factor stored in th = 'u': upper triangular uplo (global input) character Specifies whether the factor stored i = 'u': upper triangular uplo (global input) character*1 Specifies whether the upper or lower triangular part of th = 'u': upper triangular fact (global input) character Specifies whether or not the factored form of the matrix a i equilibrated before it is factored. range (global input) character
Specifies which eigenvalues are to be found
= 'v': ("value") all eigenvalues in the interval
orfac (global input) double precision orfac Specifies which eigenvectors should be orthogonalized orfac*||t|| of each other are to be orthogonalized. jobz (global input) character*1 Specifies whether or not to compute the eigenvectors = 'v': compute eigenvalues and eigenvectors. uplo (global input) character*1 Specifies whether the upper or lower triangular part of th = 'u': upper triangular jobz (global input) character*1 Specifies whether or not to compute the eigenvectors = 'v': compute eigenvalues and eigenvectors. ibtype (global input) integer Specifies the problem type to be solved = 2: sub( a )*sub( b )*x = (lambda)*x uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular norm (global input) character Specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm; trans (global input) character*1 Specifies the form of the system of equations = 't': sub( a )**t * sub( x ) = sub( b ) (transpose) uplo (global input) character Specifies whether the distributed matrix sub( a ) is uppe = 'u': upper triangular, trans (global input) character Specifies the form of the system of equations = 't': solve sub( a )**t * x = sub( b ) (transpose) ispec (global input) integer Specifies the parameter to be returned as the value o = 1: the data layout blocksize; norm (global input) character Specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm trans (global input) character*1 Specifies the form of the system of equations = 't': sub( a )**t * sub( x ) = sub( b ) (transpose) jobu (global input) character*1 Specifies options for computing u vectors) are returned in the array u; fact (global input) character Specifies whether or not the factored form of the matri whether the matrix a(ia:ia+n-1,ja:ja+n-1) should be trans (global input) character Specifies the form of the system of equations = 't': sub( a )**t * x = sub( b ) (transpose) uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is copied; the strictly uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is copied; the strictly ijob (input) integer Specifies the computation done by pslaeb endpoints of the interval. ijob (input) integer Specifies the criterion for "convergence" of an interval reltol times the larger (in magnitude) endpoint, then cmach (global input) character*1 Specifies the value to be returned by pslamch = 's' or 's , pslamch := sfmin norm (global input) character Specifies the value to be returned in pslange as describe direc (global input) character*1 Specifies in which order the permutation is applied computes p*sub( a ). direc (global input) character Specifies in which order the permutation is applied computes p * sub( a ); equed (global output) character Specifies the form of equilibration that was done = 'r': row equilibration, i.e., sub( a ) has been pre- uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular direct (global input) character*1 Specifies the order in which the elementary reflectors ar = 'f': h = h(1) h(2) . . . h(k) (forward) direct (global input) character Specifies the order in which the elementary reflectors ar = 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet) is done without over/underflow as long as the final result cto * a(i,j) / cfrom does not over/underflow. type Specifies tha hessenberg. uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is set; the strictly lower uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is set; the strictly lower direc (global input) character Specifies in which order the permutation is applied = 'b' (backward) uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character*1 Specifies whether the triangular factor stored in the matri = 'u': upper triangular, uplo (global input) character*1 Specifies whether the triangular factor stored in th = 'u': upper triangular uplo (global input) character Specifies whether the factor stored i = 'u': upper triangular uplo (global input) character*1 Specifies whether the upper or lower triangular part of th = 'u': upper triangular fact (global input) character Specifies whether or not the factored form of the matrix a i equilibrated before it is factored. range (global input) character
Specifies which eigenvalues are to be found
= 'v': ("value") all eigenvalues in the interval
orfac (global input) real orfac Specifies which eigenvectors should be orthogonalized orfac*||t|| of each other are to be orthogonalized. jobz (global input) character*1 Specifies whether or not to compute the eigenvectors = 'v': compute eigenvalues and eigenvectors. uplo (global input) character*1 Specifies whether the upper or lower triangular part of th = 'u': upper triangular jobz (global input) character*1 Specifies whether or not to compute the eigenvectors = 'v': compute eigenvalues and eigenvectors. ibtype (global input) integer Specifies the problem type to be solved = 2: sub( a )*sub( b )*x = (lambda)*x uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular norm (global input) character Specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm; trans (global input) character*1 Specifies the form of the system of equations = 't': sub( a )**t * sub( x ) = sub( b ) (transpose) uplo (global input) character Specifies whether the distributed matrix sub( a ) is uppe = 'u': upper triangular, trans (global input) character Specifies the form of the system of equations = 't': solve sub( a )**t * x = sub( b ) (transpose) norm (global input) character Specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm trans (global input) character*1 Specifies the form of the system of equations = 't': sub( a )**t * sub( x ) = sub( b ) (transpose) jobu (global input) character*1 Specifies options for computing u vectors) are returned in the array u; fact (global input) character Specifies whether or not the factored form of the matri whether the matrix a(ia:ia+n-1,ja:ja+n-1) should be trans (global input) character Specifies the form of the system of equations = 't': sub( a )**t * x = sub( b ) (transpose) jobz (global input) character*1 Specifies whether or not to compute the eigenvectors = 'v': compute eigenvalues and eigenvectors. uplo (global input) character*1 Specifies whether the upper or lower triangular part of th = 'u': upper triangular jobz (global input) character*1 Specifies whether or not to compute the eigenvectors = 'v': compute eigenvalues and eigenvectors. ibtype (global input) integer Specifies the problem type to be solved = 2: sub( a )*sub( b )*x = (lambda)*x uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is copied; the strictly uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is copied; the strictly norm (global input) character Specifies the value to be returned in pzlange as describe direc (global input) character*1 Specifies in which order the permutation is applied computes p*sub( a ). direc (global input) character Specifies in which order the permutation is applied computes p * sub( a ); equed (global output) character Specifies the form of equilibration that was done = 'r': row equilibration, i.e., sub( a ) has been pre- uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular direct (global input) character*1 Specifies the order in which the elementary reflectors ar = 'f': h = h(1) h(2) . . . h(k) (forward) direct (global input) character Specifies the order in which the elementary reflectors ar = 'f': h = h(1) h(2) . . . h(k) (forward, not supported yet) is done without over/underflow as long as the final result cto * a(i,j) / cfrom does not over/underflow. type Specifies tha hessenberg. uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is set; the strictly lower uplo (global input) character Specifies the part of the distributed matrix sub( a ) to b = 'u': upper triangular part is set; the strictly lower direc (global input) character Specifies in which order the permutation is applied = 'b' (backward) uplo (global input) character Specifies whether the upper or lower triangular part of th = 'u': upper triangular uplo (global input) character*1 Specifies whether the triangular factor stored in the matri = 'u': upper triangular, uplo (global input) character*1 Specifies whether the triangular factor stored in th = 'u': upper triangular uplo (global input) character Specifies whether the factor stored i = 'u': upper triangular uplo (global input) character*1 Specifies whether the upper or lower triangular part of th = 'u': upper triangular fact (global input) character Specifies whether or not the factored form of the matrix a i equilibrated before it is factored. orfac (global input) double precision orfac Specifies which eigenvectors should be orthogonalized orfac*||t|| of each other are to be orthogonalized. norm (global input) character Specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm; select (global input) logical array, dimension (n) if howmny = 's', select Specifies the eigenvectors to b if howmny = 'a' or 'b', select is not referenced. trans (global input) character*1 Specifies the form of the system of equations = 't': sub( a )**t * sub( x ) = sub( b ) (transpose) uplo (global input) character Specifies whether the distributed matrix sub( a ) is uppe = 'u': upper triangular, trans (global input) character Specifies the form of the system of equations = 't': solve sub( a )**t * x = sub( b ) (transpose) uplo (input) character*1 Specifies whether to solve with l or u trans (input) character istart (global input) integer Specifies the "number" of the first reflector. this i istart is ignored if block is .false.. trans (input) character Specifies the form of the system of equations = 't': l**t * x = b (transpose) uplo - character*1. on entry, uplo Specifies whether the matrix is an upper o uplo (input) character*1 Specifies whether to solve with l or u trans (input) character istart (global input) integer Specifies the "number" of the first reflector. this i istart is ignored if block is .false.. uplo (input) character*1 Specifies whether the superdiagonal or the subdiagona factorization: uplo - character*1. on entry, uplo Specifies whether the matrix is an upper o |
| specifying specifying of scalapack routines. eigenvalues/vectors can be selected by specifying a range of values or a range of indices for the desire of scalapack routines. eigenvalues/vectors can be selected by specifying a range of values or a range of indices for the desire of scalapack routines. eigenvalues/vectors can be selected by specifying a range of values or a range of indices for the desire of scalapack routines. eigenvalues/vectors can be selected by specifying a range of values or a range of indices for the desire |
| speeded speeded ieflag (input) integer a flag which indicates whether n(w) should be speeded up b ieflag (input) integer a flag which indicates whether n(w) should be speeded up b |
| spike spike the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou move entry that causes spike to auxiliary storag use the "spike" fillin to calculate contribution to previou
compute spike fill-in, l_i f_i = p_i b_{i-1
receive triangle b_{i-1} from previous processor
the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou move entry that causes spike to auxiliary storag use the "spike" fillin to calculate contribution to previou
compute spike fill-in, l_i f_i = p_i b_{i-1
receive triangle b_{i-1} from previous processor
the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou move entry that causes spike to auxiliary storag use the "spike" fillin to calculate contribution to previou
compute spike fill-in, l_i f_i = p_i b_{i-1
receive triangle b_{i-1} from previous processor
the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou move entry that causes spike to auxiliary storag use the "spike" fillin to calculate contribution to previou
compute spike fill-in, l_i f_i = p_i b_{i-1
receive triangle b_{i-1} from previous processor
the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou the right-hand-side for the triangular solve that calculates the "spike" fillin use the "spike" fillin to calculate contribution to previou |
| split split eigenvalues i+1 to ihi have already converged. either l = ilo, or h(l,l-1) is negligible so that the matrix splits converged. either l = ilo or the global a(l,l-1) is negligible so that the matrix splits eigenvalues for which eigenvectors are to be computed. the eigenvalues should be grouped by split-off block and ordere w from psstebz with order='b' is expected here). this endpoint of the j-th interval. the input intervals will, in general, be modified, split and reordered by th on input, intvl contains the minp input intervals. on entry, the off-diagonal element associated with the rank-1 cut which originally split the two submatrices which are no on exit, rho has been modified to the value required by on entry, the off-diagonal element associated with the rank-1 cut which originally split the two submatrices which are no on exit, rho has been modified to the value required by converged. either l = ilo or the global a(l,l-1) is negligible so that the matrix splits = 'b': ("by block") the eigenvalues will be grouped by
split-off block (see iblock, isplit) an
the block.
eigenvalues for which eigenvectors are to be computed. the eigenvalues should be grouped by split-off block and ordere w from pdstebz with order='b' is expected here). this endpoint of the j-th interval. the input intervals will, in general, be modified, split and reordered by th on input, intvl contains the minp input intervals. on entry, the off-diagonal element associated with the rank-1 cut which originally split the two submatrices which are no on exit, rho has been modified to the value required by on entry, the off-diagonal element associated with the rank-1 cut which originally split the two submatrices which are no on exit, rho has been modified to the value required by converged. either l = ilo or the global a(l,l-1) is negligible so that the matrix splits = 'b': ("by block") the eigenvalues will be grouped by
split-off block (see iblock, isplit) an
the block.
eigenvalues for which eigenvectors are to be computed. the eigenvalues should be grouped by split-off block and ordere w from psstebz with order='b' is expected here). this converged. either l = ilo or the global a(l,l-1) is negligible so that the matrix splits eigenvalues for which eigenvectors are to be computed. the eigenvalues should be grouped by split-off block and ordere w from pdstebz with order='b' is expected here). this eigenvalues i+1 to ihi have already converged. either l = ilo, or h(l,l-1) is negligible so that the matrix splits |
| splits splits eigenvalues i+1 to ihi have already converged. either l = ilo, or h(l,l-1) is negligible so that the matrix splits determine where the matrix splits and choose ql or qr iteratio element is smaller. converged. either l = ilo or the global a(l,l-1) is negligible so that the matrix splits converged. either l = ilo or the global a(l,l-1) is negligible so that the matrix splits converged. either l = ilo or the global a(l,l-1) is negligible so that the matrix splits converged. either l = ilo or the global a(l,l-1) is negligible so that the matrix splits determine where the matrix splits and choose ql or qr iteratio element is smaller. eigenvalues i+1 to ihi have already converged. either l = ilo, or h(l,l-1) is negligible so that the matrix splits |
| splitting splitting isplit (global input) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), isplit (global output) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), isplit (global input) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), isplit (global output) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), isplit (global input) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), isplit (global input) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), |
| spot spot in its present form, pcheev assumes a homogeneous system and makes only spot checks of the consistency of the eigenvalues across th heterogeneous system may return incorrect results without any error in its present form, pzheev assumes a homogeneous system and makes only spot checks of the consistency of the eigenvalues across th heterogeneous system may return incorrect results without any error |
| spread spread we delay spreading v across to all processor columns (whic combine the spread of v( : , i-1 ) with the spread of h( : , i ) first column of b receive data. the calls to cgebs2d/cgebr2d spread the data down arguments first column of b receive data. the calls to dgebs2d/dgebr2d spread the data down arguments we delay spreading v across to all processor columns (whic combine the spread of v( : , i-1 ) with the spread of h( : , i ) first column of b receive data. the calls to sgebs2d/sgebr2d spread the data down arguments we delay spreading v across to all processor columns (whic combine the spread of v( : , i-1 ) with the spread of h( : , i ) we delay spreading v across to all processor columns (whic combine the spread of v( : , i-1 ) with the spread of h( : , i ) first column of b receive data. the calls to zgebs2d/zgebr2d spread the data down arguments |
| spreading spreading we delay spreading v across to all processor columns (whic combine the spread of v( : , i-1 ) with the spread of h( : , i ) we delay spreading v across to all processor columns (whic combine the spread of v( : , i-1 ) with the spread of h( : , i ) we delay spreading v across to all processor columns (whic combine the spread of v( : , i-1 ) with the spread of h( : , i ) we delay spreading v across to all processor columns (whic combine the spread of v( : , i-1 ) with the spread of h( : , i ) |
| SPTTRF SPTTRF definite tridiagonal matrix a such that a = l*d*l**h (computed by SPTTRF) arguments |
| SPTTRSV SPTTRSV SPTTRSV solves one of the triangular system where l is the cholesky factor of a hermitian positive |
| SQNPC SQNPC anb = pjlaenv( ictxt, 3, 'pchettrd', 'l', 0, 0, 0, 0 ) SQNPC = sqrt( dble( nprow * npcol ) anb = pjlaenv( ictxt, 3, 'pchettrd', 'l', 0, 0, 0, 0 ) SQNPC = sqrt( dble( nprow * npcol ) anb = pjlaenv( ictxt, 3, 'pchettrd', 'l', 0, 0, 0, 0 ) SQNPC = int( sqrt( real( nprow * npcol ) ) 0, 0, 0, 0) SQNPC = int( sqrt( dble( nprow * npcol ) ) 0, 0, 0, 0) SQNPC = int( sqrt( dble( nprow * npcol ) ) nb = desca( mb_ ) anb = pjlaenv( ictxt, 3, 'pdsyttrd', 'l', 0, 0, 0, 0 ) SQNPC = int( sqrt( dble( nprow * npcol ) ) 0, 0, 0, 0) SQNPC = int( sqrt( dble( nprow * npcol ) ) 0, 0, 0, 0) SQNPC = int( sqrt( dble( nprow * npcol ) ) nb = desca( mb_ ) anb = pjlaenv( ictxt, 3, 'pssyttrd', 'l', 0, 0, 0, 0 ) SQNPC = int( sqrt( real( nprow * npcol ) ) anb = pjlaenv( ictxt, 3, 'pzhettrd', 'l', 0, 0, 0, 0 ) SQNPC = sqrt( dble( nprow * npcol ) anb = pjlaenv( ictxt, 3, 'pzhettrd', 'l', 0, 0, 0, 0 ) SQNPC = sqrt( dble( nprow * npcol ) anb = pjlaenv( ictxt, 3, 'pzhettrd', 'l', 0, 0, 0, 0 ) SQNPC = int( sqrt( dble( nprow * npcol ) ) |
| SQRT SQRT set machine-dependent constants for the stopping criterion. if norm(h) <= SQRT(ovfl), overflow should not occur anb = pjlaenv( ictxt, 3, 'pchettrd', 'l', 0, 0, 0, 0 ) sqnpc = SQRT( dble( nprow * npcol ) anb = pjlaenv( ictxt, 3, 'pchettrd', 'l', 0, 0, 0, 0 ) sqnpc = SQRT( dble( nprow * npcol ) pchentrd is faster than pchetrd on almost all matrices, particularly small ones (i.e. n < 500 * SQRT(p) ), provided tha in the following overview of the steps performed, m in the margin indicates message traffic and c indicates o(n^2 nb/SQRT(p) set machine-dependent constants for the stopping criterion. if norm(h) <= SQRT(ovfl), overflow should not occur (with respect to the two-norm). sr and sc contain the scale factors, s(i) = 1/SQRT(a(i,i)), chosen so that the scaled distri the diagonal. this choice of sr and sc puts the condition number set machine-dependent constants for the stopping criterion. if norm(h) <= SQRT(ovfl), overflow should not occur (with respect to the two-norm). sr and sc contain the scale factors, s(i) = 1/SQRT(a(i,i)), chosen so that the scaled distri the diagonal. this choice of sr and sc puts the condition number 0, 0, 0, 0) sqnpc = int( SQRT( dble( nprow * npcol ) ) 0, 0, 0, 0) sqnpc = int( SQRT( dble( nprow * npcol ) ) nb = desca( mb_ ) pdsyntrd is faster than pdsytrd on almost all matrices, particularly small ones (i.e. n < 500 * SQRT(p) ), provided tha in the following overview of the steps performed, m in the margin indicates message traffic and c indicates o(n^2 nb/SQRT(p) set machine-dependent constants for the stopping criterion. if norm(h) <= SQRT(ovfl), overflow should not occur (with respect to the two-norm). sr and sc contain the scale factors, s(i) = 1/SQRT(a(i,i)), chosen so that the scaled distri the diagonal. this choice of sr and sc puts the condition number 0, 0, 0, 0) sqnpc = int( SQRT( dble( nprow * npcol ) ) 0, 0, 0, 0) sqnpc = int( SQRT( dble( nprow * npcol ) ) nb = desca( mb_ ) pssyntrd is faster than pssytrd on almost all matrices, particularly small ones (i.e. n < 500 * SQRT(p) ), provided tha in the following overview of the steps performed, m in the margin indicates message traffic and c indicates o(n^2 nb/SQRT(p) anb = pjlaenv( ictxt, 3, 'pzhettrd', 'l', 0, 0, 0, 0 ) sqnpc = SQRT( dble( nprow * npcol ) anb = pjlaenv( ictxt, 3, 'pzhettrd', 'l', 0, 0, 0, 0 ) sqnpc = SQRT( dble( nprow * npcol ) pzhentrd is faster than pzhetrd on almost all matrices, particularly small ones (i.e. n < 500 * SQRT(p) ), provided tha in the following overview of the steps performed, m in the margin indicates message traffic and c indicates o(n^2 nb/SQRT(p) set machine-dependent constants for the stopping criterion. if norm(h) <= SQRT(ovfl), overflow should not occur (with respect to the two-norm). sr and sc contain the scale factors, s(i) = 1/SQRT(a(i,i)), chosen so that the scaled distri the diagonal. this choice of sr and sc puts the condition number set machine-dependent constants for the stopping criterion. if norm(h) <= SQRT(ovfl), overflow should not occur |
| square square this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires square block data decomposition ( mb_a=nb_a ) arguments in particular, if sub( b ) is square and nonsingular, the gq factorization of inv( sub( b ) )* sub( a ): in particular, if sub( b ) is square and nonsingular, the gr factorization of sub( a )*inv( sub( b ) ): for clustersize > n/sqrt(nprow*npcol) execution time will grow as the square of the cluster size, all other factor workspace means less reorthogonalization but faster for clustersize > n/sqrt(nprow*npcol) execution time will grow as the square of the cluster size, all other factor workspace means less reorthogonalization but faster appropriate. a must be in cyclic format (i.e. mb = nb = 1), the process grid must be square ( i.e. nprow = npcol ) an pclacon estimates the 1-norm of a square, complex distributed matri products. x and v are aligned with the distributed matrix a, this and can happen in no more than 3 locations per block assuming square blocks. there are 5 buffers that each node stores thes to send up, a buffer to send left, a buffer to send diagonally m (global input) integer m is the order of the square submatrix that is copied unchanged on exit normi denotes the infinity norm of a matrix (maximum row sum) and normf denotes the frobenius norm of a matrix (square root of sum o this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires square block data decomposition ( mb_a=nb_a ) arguments in particular, if sub( b ) is square and nonsingular, the gq factorization of inv( sub( b ) )* sub( a ): in particular, if sub( b ) is square and nonsingular, the gr factorization of sub( a )*inv( sub( b ) ): pdlabad takes as input the values computed by pdlamch for underflow and overflow, and returns the square root of each of these values i to identify machines with a large exponent range, such as the crays, pdlacon estimates the 1-norm of a square, real distributed matrix a x and v are aligned with the distributed matrix a, this information and can happen in no more than 3 locations per block assuming square blocks. there are 5 buffers that each node stores thes to send up, a buffer to send left, a buffer to send diagonally m (global input) integer m is the order of the square submatrix that is copied unchanged on exit on entry, q contains the eigenvectors of two submatrices in the two square blocks with corners at (1,1), (n1,n1 on exit, q contains the trailing (n-k) updated eigenvectors on entry, q contains the eigenvectors of two submatrices in the two square blocks with corners at (1,1), (n1,n1 on exit, q contains the trailing (n-k) updated eigenvectors normi denotes the infinity norm of a matrix (maximum row sum) and normf denotes the frobenius norm of a matrix (square root of sum o this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires square block decomposition ( mb_a = nb_a ) arguments for clustersize > n/sqrt(nprow*npcol) execution time will grow as the square of the cluster size, all other factor workspace means less reorthogonalization but faster for clustersize > n/sqrt(nprow*npcol) execution time will grow as the square of the cluster size, all other factor workspace means less reorthogonalization but faster appropriate. a must be in cyclic format (i.e. mb = nb = 1), the process grid must be square ( i.e. nprow = npcol ) an this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires square block data decomposition ( mb_a=nb_a ) arguments in particular, if sub( b ) is square and nonsingular, the gq factorization of inv( sub( b ) )* sub( a ): in particular, if sub( b ) is square and nonsingular, the gr factorization of sub( a )*inv( sub( b ) ): pslabad takes as input the values computed by pslamch for underflow and overflow, and returns the square root of each of these values i to identify machines with a large exponent range, such as the crays, pslacon estimates the 1-norm of a square, real distributed matrix a x and v are aligned with the distributed matrix a, this information and can happen in no more than 3 locations per block assuming square blocks. there are 5 buffers that each node stores thes to send up, a buffer to send left, a buffer to send diagonally m (global input) integer m is the order of the square submatrix that is copied unchanged on exit on entry, q contains the eigenvectors of two submatrices in the two square blocks with corners at (1,1), (n1,n1 on exit, q contains the trailing (n-k) updated eigenvectors on entry, q contains the eigenvectors of two submatrices in the two square blocks with corners at (1,1), (n1,n1 on exit, q contains the trailing (n-k) updated eigenvectors normi denotes the infinity norm of a matrix (maximum row sum) and normf denotes the frobenius norm of a matrix (square root of sum o this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires square block decomposition ( mb_a = nb_a ) arguments for clustersize > n/sqrt(nprow*npcol) execution time will grow as the square of the cluster size, all other factor workspace means less reorthogonalization but faster for clustersize > n/sqrt(nprow*npcol) execution time will grow as the square of the cluster size, all other factor workspace means less reorthogonalization but faster appropriate. a must be in cyclic format (i.e. mb = nb = 1), the process grid must be square ( i.e. nprow = npcol ) an this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires square block data decomposition ( mb_a=nb_a ) arguments in particular, if sub( b ) is square and nonsingular, the gq factorization of inv( sub( b ) )* sub( a ): in particular, if sub( b ) is square and nonsingular, the gr factorization of sub( a )*inv( sub( b ) ): for clustersize > n/sqrt(nprow*npcol) execution time will grow as the square of the cluster size, all other factor workspace means less reorthogonalization but faster for clustersize > n/sqrt(nprow*npcol) execution time will grow as the square of the cluster size, all other factor workspace means less reorthogonalization but faster appropriate. a must be in cyclic format (i.e. mb = nb = 1), the process grid must be square ( i.e. nprow = npcol ) an pzlacon estimates the 1-norm of a square, complex distributed matri products. x and v are aligned with the distributed matrix a, this and can happen in no more than 3 locations per block assuming square blocks. there are 5 buffers that each node stores thes to send up, a buffer to send left, a buffer to send diagonally m (global input) integer m is the order of the square submatrix that is copied unchanged on exit normi denotes the infinity norm of a matrix (maximum row sum) and normf denotes the frobenius norm of a matrix (square root of sum o this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc this routine requires square block decomposition ( mb_a = nb_a ) arguments this routine requires square block decomposition ( mb_a = nb_a ) arguments |
| squares squares 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. normf denotes the frobenius norm of a matrix (square root of sum of squares). note that max(abs(a(i,j))) is not a matrix norm notes x (input) complex the vector for which a scaled sum of squares is computed 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. d (input) double precision array, dimension (2*n - 1) contains the diagonals and the squares of the off-diagona assumed to be interleaved in memory for better cache normf denotes the frobenius norm of a matrix (square root of sum of squares). note that max(abs(a(i,j))) is not a matrix norm notes d (input) double precision array, dimension (2*n - 1) contains the diagonals and the squares of the off-diagona assumed to be interleaved in memory for better cache x (input) double precision the vector for which a scaled sum of squares is computed 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. d (input) real array, dimension (2*n - 1) contains the diagonals and the squares of the off-diagona assumed to be interleaved in memory for better cache normf denotes the frobenius norm of a matrix (square root of sum of squares). note that max(abs(a(i,j))) is not a matrix norm notes d (input) real array, dimension (2*n - 1) contains the diagonals and the squares of the off-diagona assumed to be interleaved in memory for better cache x (input) real the vector for which a scaled sum of squares is computed 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. normf denotes the frobenius norm of a matrix (square root of sum of squares). note that max(abs(a(i,j))) is not a matrix norm notes x (input) complex*16 the vector for which a scaled sum of squares is computed |
| SRC_A SRC_A the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the the columns of the array. rSRC_A (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the |
| ssq ssq pclassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, pdlassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, pslassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, pzlassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, |
| SSTEIN SSTEIN pSSTEIN computes the eigenvectors of a symmetric tridiagonal matri correspond to user specified eigenvalues. psstein does not performance. in the limit (i.e. clustersize = n-1) pSSTEIN will perform no better than sstein on for clustersize = n/sqrt(nprow*npcol) reorthogonalizing performance. in the limit (i.e. clustersize = n-1) pSSTEIN will perform no better than sstein on 1 processor all eigenvectors will increase the total execution time |
| SSTEIN2 SSTEIN2 process. pcstein decides on the allocation of work among the processes and then calls SSTEIN2 (modified lapack routine) on eac expected orthogonalization may not be done. process. psstein decides on the allocation of work among the processes and then calls SSTEIN2 (modified lapack routine) on eac expected orthogonalization may not be done. end of SSTEIN2 |
| SSTEQR2 SSTEQR2 > 0: if info = 1 through n, the i(th) eigenvalue did not converge in SSTEQR2 after a total of 30*n iterations by finding that eigenvalues were not identical across |
| SSYEVX SSYEVX pSSYEVX computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by |
| SSYTRD SSYTRD support for uplo='u' is limited to calling the old, slow, pSSYTRD |
| stably stably processors was not stably factorable wo/interchanges processors was not stably factorable wo/interchanges processors was not stably factorable wo/interchanges processors was not stably factorable wo/interchanges processors was not stably factorable wo/interchanges processors was not stably factorable wo/interchanges processors was not stably factorable wo/interchanges processors was not stably factorable wo/interchanges |
| stack stack partition d( start:endd ) and stack parts, largest one firs choose partition entry as median of 3 partition d( start:endd ) and stack parts, largest one firs choose partition entry as median of 3 partition d( start:endd ) and stack parts, largest one firs choose partition entry as median of 3 partition d( start:endd ) and stack parts, largest one firs choose partition entry as median of 3 |
| stage stage ju is the index of the last column affected by the current stage of the factorizatio ju is the index of the last column affected by the current stage of the factorizatio [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** this node stops work after this stage -- an extra cop look identical [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** this node stops work after this stage -- an extra cop look identical the eigenvectors of the original matrix are stored in q, and the eigenvalues are in d. the algorithm consists of three stages the first stage consists of deflating the size of the problem [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** this node stops work after this stage -- an extra cop look identical the eigenvectors of the original matrix are stored in q, and the eigenvalues are in d. the algorithm consists of three stages the first stage consists of deflating the size of the problem [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** this node stops work after this stage -- an extra cop look identical [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** ju is the index of the last column affected by the current stage of the factorizatio ju is the index of the last column affected by the current stage of the factorizatio |
| stages stages the eigenvectors of the original matrix are stored in q, and the eigenvalues are in d. the algorithm consists of three stages the first stage consists of deflating the size of the problem the eigenvectors of the original matrix are stored in q, and the eigenvalues are in d. the algorithm consists of three stages the first stage consists of deflating the size of the problem |
| stall stall two consecutive small subdiagonal elements will stall relatively even if each is not very small. thus it is two consecutive small subdiagonal elements will stall relatively even if each is not very small. thus it is two consecutive small subdiagonal elements will stall relatively even if each is not very small. thus it is two consecutive small subdiagonal elements will stall relatively even if each is not very small. thus it is |
| standard standard clanv2 computes the schur factorization of a complex 2-by-2 nonhermitian matrix in standard form [ a b ] = [ cs -sn ] [ aa bb ] [ cs sn ] convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t pclange, pslared1d, pslared2d, pcgebrd. using the standard notatio mp = numroc( m, mb, myrow, desca( ctxt_ ), nprow), pcheevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch pchegs2 reduces a complex hermitian-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pchegst reduces a complex hermitian-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pchengst reduces a complex hermitian-definite generalized eigenproblem to standard form pchengst performs the same function as pchegst, but is based on pclaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t pdlange, pdlared1d, pdlared2d, pdgebrd. using the standard notatio mp = numroc( m, mb, myrow, desca( ctxt_ ), nprow), pdlaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t pdsyevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch pdsygs2 reduces a real symmetric-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pdsygst reduces a real symmetric-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pdsyngst reduces a complex hermitian-definite generalized eigenproblem to standard form pdsyngst performs the same function as pdhegst, but is based on convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t pslange, pslared1d, pslared2d, psgebrd. using the standard notatio mp = numroc( m, mb, myrow, desca( ctxt_ ), nprow), pslaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t pssyevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch pssygs2 reduces a real symmetric-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pssygst reduces a real symmetric-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pssyngst reduces a complex hermitian-definite generalized eigenproblem to standard form pssyngst performs the same function as pshegst, but is based on convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t pzlange, pdlared1d, pdlared2d, pzgebrd. using the standard notatio mp = numroc( m, mb, myrow, desca( ctxt_ ), nprow), pzheevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch pzhegs2 reduces a complex hermitian-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pzhegst reduces a complex hermitian-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pzhengst reduces a complex hermitian-definite generalized eigenproblem to standard form pzhengst performs the same function as pzhegst, but is based on pzlaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t zlanv2 computes the schur factorization of a complex 2-by-2 nonhermitian matrix in standard form [ a b ] = [ cs -sn ] [ aa bb ] [ cs sn ] |
| standardised standardised on exit, they are overwritten by the elements of the standardised schur form rt1 (output) complex on exit, they are overwritten by the elements of the standardised schur form rt1 (output) complex*16 |
| Stanford Stanford see w. kahan "accurate eigenvalues of a symmetric tridiagonal matrix", report cs41, computer science dept., Stanford see w. kahan "accurate eigenvalues of a symmetric tridiagonal matrix", report cs41, computer science dept., Stanford |
| start start do insertion sort on d( start:endd do insertion sort on d( start:endd ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). difference between truea and a at the point that mvr2 is called, so we will start there let truea be the value that a would if we are starting in the middle because of consecutive smal can send through without breaking the consecutive small ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). which row & column will start the bulge ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). difference between truea and a at the point that mvr2 is called, so we will start there let truea be the value that a would ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). which row & column will start the bulge ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). difference between truea and a at the point that mvr2 is called, so we will start there let truea be the value that a would ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). difference between truea and a at the point that mvr2 is called, so we will start there let truea be the value that a would if we are starting in the middle because of consecutive smal can send through without breaking the consecutive small ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: ja (global input) integer the index in the global array a that points to the start o or a submatrix of a). do insertion sort on d( start:endd do insertion sort on d( start:endd |
| starting starting determine the effect of starting the double-shift q negligible. clamsh should only be called when there are multiple shifts/bulges (nbulge > 1) and the first shift is starting in the middle of a small subdiagonal elements. itmp1 (local input) integer starting range into a. for rows, this is the loca dlamsh should only be called when there are multiple shifts/bulges (nbulge > 1) and the first shift is starting in the middle of a subdiagonal elements. itmp1 (local input) integer starting range into a. for rows, this is the loca find starting and ending indices of block nblk holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: pclaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. if we are starting in the middle because of consecutive smal can send through without breaking the consecutive small can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are pclawil gets the transform given by h44,h33, & h43h34 into v starting at row m notes holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: pdlaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are pdlawil gets the transform given by h44,h33, & h43h34 into v starting at row m notes holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: pslaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are pslawil gets the transform given by h44,h33, & h43h34 into v starting at row m notes holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: pzlaconsb looks for two consecutive small subdiagonal elements by seeing the effect of starting a double shift qr iteratio subdiagonal negligible. if we are starting in the middle because of consecutive smal can send through without breaking the consecutive small can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are pzlawil gets the transform given by h44,h33, & h43h34 into v starting at row m notes holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: holding part of the matrix, of size 1xnp where np is adjusted, starting at csrc=0, with ja modified to reflect dropped procs first processor to hold part of the matrix: slamsh should only be called when there are multiple shifts/bulges (nbulge > 1) and the first shift is starting in the middle of a subdiagonal elements. itmp1 (local input) integer starting range into a. for rows, this is the loca find starting and ending indices of block nblk determine the effect of starting the double-shift q negligible. zlamsh should only be called when there are multiple shifts/bulges (nbulge > 1) and the first shift is starting in the middle of a small subdiagonal elements. itmp1 (local input) integer starting range into a. for rows, this is the loca |
| starts starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts up and left and a buffer to send right. each of these buffers is actually stored in one buffer buf where buf(istr1+1) starts the values are stored, if there are any values that a node i (global input) integer a(i,i) is the global location that the copying starts from the main implicit shift francis loops over the bulges starts m (global input) integer on entry, this is where the transform starts (row m. the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts up and left and a buffer to send right. each of these buffers is actually stored in one buffer buf where buf(istr1+1) starts the values are stored, if there are any values that a node i (global input) integer a(i,i) is the global location that the copying starts from m (global input) integer on entry, this is where the transform starts (row m. the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts up and left and a buffer to send right. each of these buffers is actually stored in one buffer buf where buf(istr1+1) starts the values are stored, if there are any values that a node i (global input) integer a(i,i) is the global location that the copying starts from m (global input) integer on entry, this is where the transform starts (row m. the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts up and left and a buffer to send right. each of these buffers is actually stored in one buffer buf where buf(istr1+1) starts the values are stored, if there are any values that a node i (global input) integer a(i,i) is the global location that the copying starts from the main implicit shift francis loops over the bulges starts m (global input) integer on entry, this is where the transform starts (row m. the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts the distance for sending and receiving for each level starts |
| state state temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo |
| stated stated h = h( liip1:n, bindex ) and bindex = 0 indeed, the previous loop invariant as stated above for th are null matrices. h = h( liip1:n, bindex ) and bindex = 0 indeed, the previous loop invariant as stated above for th are null matrices. h = h( liip1:n, bindex ) and bindex = 0 indeed, the previous loop invariant as stated above for th are null matrices. h = h( liip1:n, bindex ) and bindex = 0 indeed, the previous loop invariant as stated above for th are null matrices. |
| Statement Statement .. .. Statement functions . .. statement function definitions .. .. .. Statement functions . .. statement function definitions .. .. .. Statement functions . .. statement function definitions .. .. .. Statement functions . .. statement function definitions .. .. .. Statement functions . .. statement function definitions .. .. .. Statement functions . .. statement function definitions .. |
| Statements Statements .. .. executable Statements . kv is the number of superdiagonals in the factor u .. .. executable Statements . .. .. executable Statements . kv is the number of superdiagonals in the factor u .. .. executable Statements . test the input paramters. .. .. executable Statements . test the input paramters. .. .. executable Statements . test the input parameters. .. .. executable Statements . test the input parameters. .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . .. .. executable Statements . .. .. executable Statements . get grid parameters and local indexes. .. .. executable Statements . get grid parameters. .. .. executable Statements . get grid parameters and local indexes. .. .. executable Statements . get grid parameters .. .. executable Statements . quick return if possible .. .. executable Statements . quick return if possible .. .. executable Statements . quick return if possible .. .. executable Statements . quick return if possible .. .. executable Statements . get grid parameters .. .. executable Statements . .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . .. .. executable Statements . .. .. executable Statements . get grid parameters. .. .. executable Statements . get grid parameters and local indexes. .. .. executable Statements . get grid parameters .. .. executable Statements . quick return if possible .. .. executable Statements . quick return if possible .. .. executable Statements . get grid parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . .. .. executable Statements . .. .. executable Statements . get grid parameters. .. .. executable Statements . get grid parameters and local indexes. .. .. executable Statements . get grid parameters .. .. executable Statements . quick return if possible .. .. executable Statements . quick return if possible .. .. executable Statements . get grid parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . .. .. executable Statements . .. .. executable Statements . get grid parameters and local indexes. .. .. executable Statements . get grid parameters. .. .. executable Statements . get grid parameters and local indexes. .. .. executable Statements . get grid parameters .. .. executable Statements . quick return if possible .. .. executable Statements . quick return if possible .. .. executable Statements . quick return if possible .. .. executable Statements . quick return if possible .. .. executable Statements . get grid parameters .. .. executable Statements . .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . test the input parameters .. .. executable Statements . kv is the number of superdiagonals in the factor u .. .. executable Statements . test the input paramters. .. .. executable Statements . test the input paramters. .. .. executable Statements . test the input parameters. .. .. executable Statements . test the input parameters. .. .. executable Statements . kv is the number of superdiagonals in the factor u .. .. executable Statements . |
| static static the interval [vl, vu], or the eigenvalues indexed il through iu. a static partitioning of work is done at the beginning of pdstebz whic eigenvalues. the interval [vl, vu], or the eigenvalues indexed il through iu. a static partitioning of work is done at the beginning of psstebz whic eigenvalues. |
| stays stays work is done on that. at the end of the border, the data is passed back and everything stays a lot simpler work is done on that. at the end of the border, the data is passed back and everything stays a lot simpler work is done on that. at the end of the border, the data is passed back and everything stays a lot simpler work is done on that. at the end of the border, the data is passed back and everything stays a lot simpler |
| step step the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of 1 or 2. each iteration of the loop work eigenvalues i+1 to ihi have already converged. either l = ilo, or skip the current step: the subdiagonal info is just noise the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of 1 or 2. each iteration of the loop work eigenvalues i+1 to ihi have already converged. either l = ilo, or skip the current step: the subdiagonal info is just noise |
| steps steps the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of 1 or 2. each iteration of the loop work eigenvalues i+1 to ihi have already converged. either l = ilo, or this is the lookahead loop, going until we have convergence or too many steps have been taken determine number of steps in tree loo determine number of steps in tree loo itmax is the maximum number of steps of iterative refinement notes the following steps are performed 1. if fact = 'e', real scaling factors are computed to equilibrate in the following overview of the steps performed, m in th or more flops per processor. the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already determine number of steps in tree loo itmax is the maximum number of steps of iterative refinement notes the following steps are performed 1. if fact = 'e', real scaling factors are computed to equilibrate determine number of steps in tree loo determine number of steps in tree loo determine number of steps in tree loo itmax is the maximum number of steps of iterative refinement notes the following steps are performed 1. if fact = 'e', real scaling factors are computed to equilibrate the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already determine number of steps in tree loo itmax is the maximum number of steps of iterative refinement notes the following steps are performed 1. if fact = 'e', real scaling factors are computed to equilibrate determine number of steps in tree loo in the following overview of the steps performed, m in th or more flops per processor. determine number of steps in tree loo determine number of steps in tree loo itmax is the maximum number of steps of iterative refinement notes the following steps are performed 1. if fact = 'e', real scaling factors are computed to equilibrate the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already determine number of steps in tree loo itmax is the maximum number of steps of iterative refinement notes the following steps are performed 1. if fact = 'e', real scaling factors are computed to equilibrate determine number of steps in tree loo in the following overview of the steps performed, m in th or more flops per processor. determine number of steps in tree loo determine number of steps in tree loo itmax is the maximum number of steps of iterative refinement notes the following steps are performed 1. if fact = 'e', real scaling factors are computed to equilibrate in the following overview of the steps performed, m in th or more flops per processor. the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of our schur block size (<=2*iblk). eac and columns l to i. eigenvalues i+1 to ihi have already determine number of steps in tree loo itmax is the maximum number of steps of iterative refinement notes the following steps are performed 1. if fact = 'e', real scaling factors are computed to equilibrate determine number of steps in tree loo the main loop begins here. i is the loop index and decreases from ihi to ilo in steps of 1 or 2. each iteration of the loop work eigenvalues i+1 to ihi have already converged. either l = ilo, or this is the lookahead loop, going until we have convergence or too many steps have been taken |
| still still indeed, the previous loop invariant as stated above for the top of the loop still holds, but with bindex = 0, h and indeed, the previous loop invariant as stated above for the top of the loop still holds, but with bindex = 0, h and indeed, the previous loop invariant as stated above for the top of the loop still holds, but with bindex = 0, h and indeed, the previous loop invariant as stated above for the top of the loop still holds, but with bindex = 0, h and |
| stopping stopping set machine-dependent constants for the stopping criterion compute reorthogonalization criterion and stopping criterion set machine-dependent constants for the stopping criterion can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are set machine-dependent constants for the stopping criterion can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are set machine-dependent constants for the stopping criterion can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are set machine-dependent constants for the stopping criterion can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are can be obtained by adding along row i and column i of the the triangular matrix, stopping/starting at the diagonal, which i in the following code, the row sums created by --- rows below are compute reorthogonalization criterion and stopping criterion set machine-dependent constants for the stopping criterion |
| stops stops this node stops work after this stage -- an extra cop look identical this node stops work after this stage -- an extra cop look identical this node stops work after this stage -- an extra cop look identical this node stops work after this stage -- an extra cop look identical |
| storage storage ab (input/output) complex array, dimension (ldab,n) on entry, the matrix a in band storage, in rows kl+1 t the j-th column of a is stored in the j-th column of the ab (input/output) double precision array, dimension (ldab,n) on entry, the matrix a in band storage, in rows kl+1 t the j-th column of a is stored in the j-th column of the check auxiliary storage siz first copy and multiply it into temporary storage check auxiliary storage siz check auxiliary storage siz data storage requirement where ldw is equal to the workspace necessary for transposition, and the storage of the tranposed ipiv let lcm be the least common multiple of nprow and npcol. the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding type (global input) character type indices the storage type of the input distribute = 'g': sub( a ) is a full matrix, check auxiliary storage siz first copy and multiply it into temporary storage contains the triangular factor u or l from the cholesky factorization a = u**t*u or a = l*l**t, in the same storage of the equilibrated matrix diag(sr)*a*diag(sc). check auxiliary storage siz lwork controls the extent of orthogonalization which can be done. the number of eigenvectors for which storage i nvec = floor(( lwork- max(5*n,np00*mq00) )/n). to be 1. on exit, the (triangular) inverse of the original matrix, in the same storage format ia (global input) integer check auxiliary storage siz first copy and multiply it into temporary storage check auxiliary storage siz check auxiliary storage siz where ldw is equal to the workspace necessary for transposition, and the storage of the tranposed ipiv let lcm be the least common multiple of nprow and npcol. the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding type (global input) character type indices the storage type of the input distribute = 'g': sub( a ) is a full matrix, check auxiliary storage siz first copy and multiply it into temporary storage contains the triangular factor u or l from the cholesky factorization a = u**t*u or a = l*l**t, in the same storage of the equilibrated matrix diag(sr)*a*diag(sc). check auxiliary storage siz lwork controls the extent of orthogonalization which can be done. the number of eigenvectors for which storage i nvec = floor(( lwork- max(5*n,np00*mq00) )/n). data storage requirement to be 1. on exit, the (triangular) inverse of the original matrix, in the same storage format ia (global input) integer check auxiliary storage siz first copy and multiply it into temporary storage check auxiliary storage siz check auxiliary storage siz where ldw is equal to the workspace necessary for transposition, and the storage of the tranposed ipiv let lcm be the least common multiple of nprow and npcol. the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding type (global input) character type indices the storage type of the input distribute = 'g': sub( a ) is a full matrix, check auxiliary storage siz first copy and multiply it into temporary storage contains the triangular factor u or l from the cholesky factorization a = u**t*u or a = l*l**t, in the same storage of the equilibrated matrix diag(sr)*a*diag(sc). check auxiliary storage siz lwork controls the extent of orthogonalization which can be done. the number of eigenvectors for which storage i nvec = floor(( lwork- max(5*n,np00*mq00) )/n). data storage requirement to be 1. on exit, the (triangular) inverse of the original matrix, in the same storage format ia (global input) integer check auxiliary storage siz first copy and multiply it into temporary storage check auxiliary storage siz check auxiliary storage siz data storage requirement where ldw is equal to the workspace necessary for transposition, and the storage of the tranposed ipiv let lcm be the least common multiple of nprow and npcol. the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding the shape of the matrix v and the storage of the vectors which defin k = 3. the elements equal to 1 are not stored; the corresponding type (global input) character type indices the storage type of the input distribute = 'g': sub( a ) is a full matrix, check auxiliary storage siz first copy and multiply it into temporary storage contains the triangular factor u or l from the cholesky factorization a = u**t*u or a = l*l**t, in the same storage of the equilibrated matrix diag(sr)*a*diag(sc). check auxiliary storage siz lwork controls the extent of orthogonalization which can be done. the number of eigenvectors for which storage i nvec = floor(( lwork- max(5*n,np00*mq00) )/n). to be 1. on exit, the (triangular) inverse of the original matrix, in the same storage format ia (global input) integer ab (input/output) real array, dimension (ldab,n) on entry, the matrix a in band storage, in rows kl+1 t the j-th column of a is stored in the j-th column of the ab (input/output) complex*16 array, dimension (ldab,n) on entry, the matrix a in band storage, in rows kl+1 t the j-th column of a is stored in the j-th column of the |
| store store 2*kl+ku+1; rows 1 to kl of the array need not be set. the j-th column of a is stored in the j-th column of th ab(kl+ku+1+i-j,j) = a(i,j) for max(1,j-ku)<=i<=min(m,j+kl) 2*kl+ku+1; rows 1 to kl of the array need not be set. the j-th column of a is stored in the j-th column of th ab(kl+ku+1+i-j,j) = a(i,j) for max(1,j-ku)<=i<=min(m,j+kl) if stopping criterion was not satisfied, update info and store eigenvector number in array ifail discard temporary matrix stored beginning i off_diagonal block of reduced system. calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, store each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. 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 find sum of global matrix columns and store on row 0 o 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 find sum of global matrix columns and store on row 0 o discard temporary matrix stored beginning i off_diagonal block of reduced system. calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, store
{f_i}^c = {h_i}{{b'}_i}^c
each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. discard temporary matrix stored beginning i off_diagonal block of reduced system. calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, store each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. find sum of global matrix columns and store on row 0 o 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 find sum of global matrix columns and store on row 0 o discard temporary matrix stored beginning i off_diagonal block of reduced system. calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, store
{f_i}^t = {h_i}{{b'}_i}^t
discard temporary matrix stored beginning i off_diagonal block of reduced system. calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, store each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. find sum of global matrix columns and store on row 0 o 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 find sum of global matrix columns and store on row 0 o discard temporary matrix stored beginning i off_diagonal block of reduced system. calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, store
{f_i}^t = {h_i}{{b'}_i}^t
discard temporary matrix stored beginning i off_diagonal block of reduced system. calculate off-diagonal block(s) of reduced system. note: for ease of use in solution of reduced system, store each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. 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 find sum of global matrix columns and store on row 0 o 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 find sum of global matrix columns and store on row 0 o discard temporary matrix stored beginning i off_diagonal block of reduced system. calculate off-diagonal block(s) of reduced system.
note: for ease of use in solution of reduced system, store
{f_i}^c = {h_i}{{b'}_i}^c
each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. 2*kl+ku+1; rows 1 to kl of the array need not be set. the j-th column of a is stored in the j-th column of th ab(kl+ku+1+i-j,j) = a(i,j) for max(1,j-ku)<=i<=min(m,j+kl) if stopping criterion was not satisfied, update info and store eigenvector number in array ifail 2*kl+ku+1; rows 1 to kl of the array need not be set. the j-th column of a is stored in the j-th column of th ab(kl+ku+1+i-j,j) = a(i,j) for max(1,j-ku)<=i<=min(m,j+kl) |
| stored stored 2*kl+ku+1; rows 1 to kl of the array need not be set. the j-th column of a is stored in the j-th column of th ab(kl+ku+1+i-j,j) = a(i,j) for max(1,j-ku)<=i<=min(m,j+kl) specifies whether the superdiagonal or the subdiagonal of the tridiagonal matrix a is stored and the form of th = 'u': e is the superdiagonal of u, and a = u'*d*u; 2*kl+ku+1; rows 1 to kl of the array need not be set. the j-th column of a is stored in the j-th column of th ab(kl+ku+1+i-j,j) = a(i,j) for max(1,j-ku)<=i<=min(m,j+kl) local memory to an array with first dimension lld_a >=(bwl+bwu+1) (stored in desca) this local portion is stored in the packed banded format discard temporary matrix stored beginning i off_diagonal block of reduced system. where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pcdbtrf banded diagonally dominant-like distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s info = -i. > 0: if info = k<=nprocs, the submatrix stored on processo diagonally dominant-like, and receive cont. to diagonal block that is stored on this proc where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pcdttrf tridiagonal diagonally dominant-like distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s local memory to an array with first dimension lld_a >=(2*bwl+2*bwu+1) (stored in desca) this local portion is stored in the packed banded format where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pcgbtrf banded distributed notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, vectors b and solution vectors x can be handled in a single call; when trans = 'n', the solution vectors are stored as the columns o right hand side matrix sub( b ) otherwise. notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, tation matrix, l is unit lower triangular, and u is upper triangular. l and u are stored in sub( a ). the factored form of sub( a ) is the notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, ments (lower trapezoidal if m > n), and u is upper triangular (upper trapezoidal if m < n). l and u are stored in sub( a ) this is the right-looking parallel level 3 blas version of the notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_) the descriptor type. specifies whether the upper or lower triangular part of the symmetric matrix a is stored = 'l': lower triangular notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, set all values for bulges. all bulges are stored i over the global m to i-1 values is always k1(ki) to k2(ki). where tau is a complex scalar, and v is a complex vector with v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit i notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, irsc0 : pointer to part of work used to store the rowsums while they are stored along a process colum they have been transposed to be along a process row irsc0 : pointer to part of work used to store the rowsums while they are stored along a process colum they have been transposed to be along a process row notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, if storev = 'c', the vector which defines the elementary reflector h(i) is stored in the i-th column of the distributed matrix v, an h = i - v * t * v' notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, if storev = 'c', the vector which defines the elementary reflector h(i) is stored in the i-th column of the array v, an h = i - v * t * v' notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, 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 notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored discard temporary matrix stored beginning i off_diagonal block of reduced system. where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pcpbtrf banded symmetric positive definite distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, the scaling factor are stored along process rows in sr and alon greatly the application of the factors. notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored receive cont. to diagonal block that is stored on this proc where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pcpttrf tridiagonal symmetric positive definite distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s notation stored in explanatio dt_a (global) desca[ dt_ ] the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, local memory to an array with first dimension lld_a >=(bwl+bwu+1) (stored in desca) this local portion is stored in the packed banded format discard temporary matrix stored beginning i off_diagonal block of reduced system. where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pddbtrf banded diagonally dominant-like distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s info = -i. > 0: if info = k<=nprocs, the submatrix stored on processo diagonally dominant-like, and receive cont. to diagonal block that is stored on this proc where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pddttrf tridiagonal diagonally dominant-like distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s local memory to an array with first dimension lld_a >=(2*bwl+2*bwu+1) (stored in desca) this local portion is stored in the packed banded format where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pdgbtrf banded distributed notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, vectors b and solution vectors x can be handled in a single call; when trans = 'n', the solution vectors are stored as the columns o right hand side matrix sub( b ) otherwise. notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, tation matrix, l is unit lower triangular, and u is upper triangular. l and u are stored in sub( a ). the factored form of sub( a ) is the notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, ments (lower trapezoidal if m > n), and u is upper triangular (upper trapezoidal if m < n). l and u are stored in sub( a ) this is the right-looking parallel level 3 blas version of the notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, the eigenvectors of the original matrix are stored in q, and th notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, set all values for bulges. all bulges are stored i over the global m to i-1 values is always k1(ki) to k2(ki). where tau is a real scalar, and v is a real vector with v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit i notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, irsc0 : pointer to part of work used to store the rowsums while they are stored along a process colum they have been transposed to be along a process row notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, if storev = 'c', the vector which defines the elementary reflector h(i) is stored in the i-th column of the distributed matrix v, an h = i - v * t * v' notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, if storev = 'c', the vector which defines the elementary reflector h(i) is stored in the i-th column of the array v, an h = i - v * t * v' notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, 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 notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored discard temporary matrix stored beginning i off_diagonal block of reduced system. where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pdpbtrf banded symmetric positive definite distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, the scaling factor are stored along process rows in sr and alon greatly the application of the factors. notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, info = -i. > 0: if info = k<=nprocs, the submatrix stored on processo positive definite, and receive cont. to diagonal block that is stored on this proc where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pdpttrf tridiagonal symmetric positive definite distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s notation stored in explanatio dt_a (global) desca[ dt_ ] the descriptor type. in this case, specifies the order in which the eigenvalues and their block numbers are stored in w and iblock split-off block (see iblock, isplit) and notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_) the descriptor type. specifies whether the upper or lower triangular part of the symmetric matrix a is stored = 'l': lower triangular notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, local memory to an array with first dimension lld_a >=(bwl+bwu+1) (stored in desca) this local portion is stored in the packed banded format discard temporary matrix stored beginning i off_diagonal block of reduced system. where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by psdbtrf banded diagonally dominant-like distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s info = -i. > 0: if info = k<=nprocs, the submatrix stored on processo diagonally dominant-like, and receive cont. to diagonal block that is stored on this proc where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by psdttrf tridiagonal diagonally dominant-like distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s local memory to an array with first dimension lld_a >=(2*bwl+2*bwu+1) (stored in desca) this local portion is stored in the packed banded format where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by psgbtrf banded distributed notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, vectors b and solution vectors x can be handled in a single call; when trans = 'n', the solution vectors are stored as the columns o right hand side matrix sub( b ) otherwise. notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, tation matrix, l is unit lower triangular, and u is upper triangular. l and u are stored in sub( a ). the factored form of sub( a ) is the notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, ments (lower trapezoidal if m > n), and u is upper triangular (upper trapezoidal if m < n). l and u are stored in sub( a ) this is the right-looking parallel level 3 blas version of the notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, the eigenvectors of the original matrix are stored in q, and th notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, set all values for bulges. all bulges are stored i over the global m to i-1 values is always k1(ki) to k2(ki). where tau is a real scalar, and v is a real vector with v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit i notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, irsc0 : pointer to part of work used to store the rowsums while they are stored along a process colum they have been transposed to be along a process row notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, if storev = 'c', the vector which defines the elementary reflector h(i) is stored in the i-th column of the distributed matrix v, an h = i - v * t * v' notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, if storev = 'c', the vector which defines the elementary reflector h(i) is stored in the i-th column of the array v, an h = i - v * t * v' notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, 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 notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored discard temporary matrix stored beginning i off_diagonal block of reduced system. where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pspbtrf banded symmetric positive definite distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, the scaling factor are stored along process rows in sr and alon greatly the application of the factors. notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, info = -i. > 0: if info = k<=nprocs, the submatrix stored on processo positive definite, and receive cont. to diagonal block that is stored on this proc where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pspttrf tridiagonal symmetric positive definite distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s notation stored in explanatio dt_a (global) desca[ dt_ ] the descriptor type. in this case, specifies the order in which the eigenvalues and their block numbers are stored in w and iblock split-off block (see iblock, isplit) and notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_) the descriptor type. specifies whether the upper or lower triangular part of the symmetric matrix a is stored = 'l': lower triangular notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, local memory to an array with first dimension lld_a >=(bwl+bwu+1) (stored in desca) this local portion is stored in the packed banded format discard temporary matrix stored beginning i off_diagonal block of reduced system. where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pzdbtrf banded diagonally dominant-like distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s notation stored in explanatio dt_a (global) desca[ dt_ ] the descriptor type. in this case, info = -i. > 0: if info = k<=nprocs, the submatrix stored on processo diagonally dominant-like, and receive cont. to diagonal block that is stored on this proc where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pzdttrf tridiagonal diagonally dominant-like distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s local memory to an array with first dimension lld_a >=(2*bwl+2*bwu+1) (stored in desca) this local portion is stored in the packed banded format where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pzgbtrf banded distributed notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, vectors b and solution vectors x can be handled in a single call; when trans = 'n', the solution vectors are stored as the columns o right hand side matrix sub( b ) otherwise. notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, tation matrix, l is unit lower triangular, and u is upper triangular. l and u are stored in sub( a ). the factored form of sub( a ) is the notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, ments (lower trapezoidal if m > n), and u is upper triangular (upper trapezoidal if m < n). l and u are stored in sub( a ) this is the right-looking parallel level 3 blas version of the notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_) the descriptor type. specifies whether the upper or lower triangular part of the symmetric matrix a is stored = 'l': lower triangular notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, set all values for bulges. all bulges are stored i over the global m to i-1 values is always k1(ki) to k2(ki). where tau is a complex scalar, and v is a complex vector with v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit i notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, irsc0 : pointer to part of work used to store the rowsums while they are stored along a process colum they have been transposed to be along a process row irsc0 : pointer to part of work used to store the rowsums while they are stored along a process colum they have been transposed to be along a process row notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, if storev = 'c', the vector which defines the elementary reflector h(i) is stored in the i-th column of the distributed matrix v, an h = i - v * t * v' notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, if storev = 'c', the vector which defines the elementary reflector h(i) is stored in the i-th column of the array v, an h = i - v * t * v' notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, 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 notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored discard temporary matrix stored beginning i off_diagonal block of reduced system. where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pzpbtrf banded symmetric positive definite distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, the scaling factor are stored along process rows in sr and alon greatly the application of the factors. notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, uplo (global input) character = 'u': upper triangle of a(1:n, ja:ja+n-1) is stored receive cont. to diagonal block that is stored on this proc where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pzpttrf tridiagonal symmetric positive definite distributed use factorization of odd-even connection block to modify locally stored portion of right hand side(s notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, notation stored in explanatio dtype_a(global) desca( dtype_ )the descriptor type. in this case, 2*kl+ku+1; rows 1 to kl of the array need not be set. the j-th column of a is stored in the j-th column of th ab(kl+ku+1+i-j,j) = a(i,j) for max(1,j-ku)<=i<=min(m,j+kl) 2*kl+ku+1; rows 1 to kl of the array need not be set. the j-th column of a is stored in the j-th column of th ab(kl+ku+1+i-j,j) = a(i,j) for max(1,j-ku)<=i<=min(m,j+kl) specifies whether the superdiagonal or the subdiagonal of the tridiagonal matrix a is stored and the form of th = 'u': e is the superdiagonal of u, and a = u'*d*u; |
| stores stores each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. a description vector is associated with each 2d block-cyclicly dis- tributed matrix. this vector stores the information required t process and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis process and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. matrix with bandwidth bw. depending on the value of uplo, a stores either u or l in the equ each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. matrix. depending on the value of uplo, a stores either u or l in the equ each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. matrix with bandwidth bw. depending on the value of uplo, a stores either u or l in the equ each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. a description vector is associated with each 2d block-cyclicly dis- tributed matrix. this vector stores the information required t process and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis process and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. matrix with bandwidth bw. depending on the value of uplo, a stores either u or l in the equ each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. a description vector is associated with each 2d block-cyclicly dis- tributed matrix. this vector stores the information required t process and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis process and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. a description vector is associated with each 2d block-cyclicly dis- tributed matrix. this vector stores the information required t process and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis process and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. matrix with bandwidth bw. depending on the value of uplo, a stores either u or l in the equ each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. matrix. depending on the value of uplo, a stores either u or l in the equ each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. each global data object is described by an associated description vector. this vector stores the information required to establis and memory location. |
| STOREV STOREV STOREV (global input) characte reflectors are stored: if STOREV = 'c', the vector which defines the elementary reflecto currently, only STOREV = 'r' and direct = 'b' are supported notes if STOREV = 'c', the vector which defines the elementary reflecto STOREV (global input) characte reflectors are stored: if STOREV = 'c', the vector which defines the elementary reflecto currently, only STOREV = 'r' and direct = 'b' are supported notes if STOREV = 'c', the vector which defines the elementary reflecto STOREV (global input) characte reflectors are stored: if STOREV = 'c', the vector which defines the elementary reflecto currently, only STOREV = 'r' and direct = 'b' are supported notes if STOREV = 'c', the vector which defines the elementary reflecto STOREV (global input) characte reflectors are stored: if STOREV = 'c', the vector which defines the elementary reflecto currently, only STOREV = 'r' and direct = 'b' are supported notes if STOREV = 'c', the vector which defines the elementary reflecto |
| storing storing lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. dl (local input/local output) complex pointer to local part of global vector storing the lower diagonal of th aligned with d. dl (local input/local output) complex pointer to local part of global vector storing the lower diagonal of th aligned with d. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( lld_ ) the leading dimension of the local array storing the local blocks of th lld_a >= max(1,locr(m_a)). lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. d (local input/local output) complex pointer to local part of global vector storing the main diagonal of th on exit, this array contains information containing the d (local input/local output) complex pointer to local part of global vector storing the main diagonal of th on exit, this array contains information containing the lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. dl (local input/local output) double precision pointer to local part of global vector storing the lower diagonal of th aligned with d. dl (local input/local output) double precision pointer to local part of global vector storing the lower diagonal of th aligned with d. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. d (local input/local output) double precision pointer to local part of global vector storing the main diagonal of th on exit, this array contains information containing the d (local input/local output) double precision pointer to local part of global vector storing the main diagonal of th on exit, this array contains information containing the lld_a (local) desca( lld_ ) the leading dimension of the local array storing the local blocks of th lld_a >= max(1,locr(m_a)). lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. dl (local input/local output) real pointer to local part of global vector storing the lower diagonal of th aligned with d. dl (local input/local output) real pointer to local part of global vector storing the lower diagonal of th aligned with d. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. d (local input/local output) real pointer to local part of global vector storing the main diagonal of th on exit, this array contains information containing the d (local input/local output) real pointer to local part of global vector storing the main diagonal of th on exit, this array contains information containing the lld_a (local) desca( lld_ ) the leading dimension of the local array storing the local blocks of th lld_a >= max(1,locr(m_a)). lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. dl (local input/local output) complex*16 pointer to local part of global vector storing the lower diagonal of th aligned with d. dl (local input/local output) complex*16 pointer to local part of global vector storing the lower diagonal of th aligned with d. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( lld_ ) the leading dimension of the local array storing the local blocks of th lld_a >= max(1,locr(m_a)). lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. lld_a (local) desca( 6 ) the leading dimension of the local array storing the local blocks of the distri depends on type_a. d (local input/local output) complex*16 pointer to local part of global vector storing the main diagonal of th on exit, this array contains information containing the d (local input/local output) complex*16 pointer to local part of global vector storing the main diagonal of th on exit, this array contains information containing the |
| strictly strictly upper triangular part of the array t must contain the upper triangular matrix and the strictly lower triangular part o before entry with uplo = 'l' or 'l', the leading n by n upper triangular part of the array t must contain the upper triangular matrix and the strictly lower triangular part o before entry with uplo = 'l' or 'l', the leading n by n the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the copied: = 'u': upper triangular part is copied; the strictly = 'l': lower triangular part is copied; the strictly copied: = 'u': upper triangular part is copied; the strictly = 'l': lower triangular part is copied; the strictly triangular part of sub( a ) contains the upper triangular part of the matrix, and the strictly lower triangular par n-by-n lower triangular part of sub( a ) contains the lower set: = 'u': upper triangular part is set; the strictly lowe = 'l': lower triangular part is set; the strictly upper set: = 'u': upper triangular part is set; the strictly lowe = 'l': lower triangular part is set; the strictly upper leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the no communication is performed by this routine, the matrix to operate on should be strictly local to one process notes sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- n-by-n upper triangular part of a contains the upper triangular part of the matrix a, and the strictly lowe leading n-by-n lower triangular part of a contains the lower sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- n-by-n upper triangular part of this distributed matrix con- tains the upper triangular matrix, and its strictly lowe leading n-by-n lower triangular part of this ditributed sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- part of the matrix sub( a ) contains the upper triangular matrix, and the strictly lower triangular part of sub( a triangular part of the matrix sub( a ) contains the lower n-by-n upper triangular part of the matrix sub( a ) contains the upper triangular matrix to be inverted, and the strictly if uplo = 'l', the leading n-by-n lower triangular part of triangular part of sub( a ) contains the upper triangular matrix, and the strictly lower triangular part of sub( a triangular part of sub( a ) contains the lower triangular copied: = 'u': upper triangular part is copied; the strictly = 'l': lower triangular part is copied; the strictly copied: = 'u': upper triangular part is copied; the strictly = 'l': lower triangular part is copied; the strictly triangular part of sub( a ) contains the upper triangular part of the matrix, and the strictly lower triangular par n-by-n lower triangular part of sub( a ) contains the lower set: = 'u': upper triangular part is set; the strictly lowe = 'l': lower triangular part is set; the strictly upper set: = 'u': upper triangular part is set; the strictly lowe = 'l': lower triangular part is set; the strictly upper leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the no communication is performed by this routine, the matrix to operate on should be strictly local to one process notes sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- n-by-n upper triangular part of a contains the upper triangular part of the matrix a, and the strictly lowe leading n-by-n lower triangular part of a contains the lower sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the n-by-n upper triangular part of this distributed matrix con- tains the upper triangular matrix, and its strictly lowe leading n-by-n lower triangular part of this ditributed sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- part of the matrix sub( a ) contains the upper triangular matrix, and the strictly lower triangular part of sub( a triangular part of the matrix sub( a ) contains the lower n-by-n upper triangular part of the matrix sub( a ) contains the upper triangular matrix to be inverted, and the strictly if uplo = 'l', the leading n-by-n lower triangular part of triangular part of sub( a ) contains the upper triangular matrix, and the strictly lower triangular part of sub( a triangular part of sub( a ) contains the lower triangular copied: = 'u': upper triangular part is copied; the strictly = 'l': lower triangular part is copied; the strictly copied: = 'u': upper triangular part is copied; the strictly = 'l': lower triangular part is copied; the strictly triangular part of sub( a ) contains the upper triangular part of the matrix, and the strictly lower triangular par n-by-n lower triangular part of sub( a ) contains the lower set: = 'u': upper triangular part is set; the strictly lowe = 'l': lower triangular part is set; the strictly upper set: = 'u': upper triangular part is set; the strictly lowe = 'l': lower triangular part is set; the strictly upper leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the no communication is performed by this routine, the matrix to operate on should be strictly local to one process notes sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- n-by-n upper triangular part of a contains the upper triangular part of the matrix a, and the strictly lowe leading n-by-n lower triangular part of a contains the lower sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the n-by-n upper triangular part of this distributed matrix con- tains the upper triangular matrix, and its strictly lowe leading n-by-n lower triangular part of this ditributed sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- part of the matrix sub( a ) contains the upper triangular matrix, and the strictly lower triangular part of sub( a triangular part of the matrix sub( a ) contains the lower n-by-n upper triangular part of the matrix sub( a ) contains the upper triangular matrix to be inverted, and the strictly if uplo = 'l', the leading n-by-n lower triangular part of triangular part of sub( a ) contains the upper triangular matrix, and the strictly lower triangular part of sub( a triangular part of sub( a ) contains the lower triangular the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the copied: = 'u': upper triangular part is copied; the strictly = 'l': lower triangular part is copied; the strictly copied: = 'u': upper triangular part is copied; the strictly = 'l': lower triangular part is copied; the strictly triangular part of sub( a ) contains the upper triangular part of the matrix, and the strictly lower triangular par n-by-n lower triangular part of sub( a ) contains the lower set: = 'u': upper triangular part is set; the strictly lowe = 'l': lower triangular part is set; the strictly upper set: = 'u': upper triangular part is set; the strictly lowe = 'l': lower triangular part is set; the strictly upper leading n-by-n upper triangular part of sub( a ) contains the upper triangular part of the matrix, and its strictly leading n-by-n lower triangular part of sub( a ) contains the no communication is performed by this routine, the matrix to operate on should be strictly local to one process notes sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- n-by-n upper triangular part of a contains the upper triangular part of the matrix a, and the strictly lowe leading n-by-n lower triangular part of a contains the lower sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- n-by-n upper triangular part of this distributed matrix con- tains the upper triangular matrix, and its strictly lowe leading n-by-n lower triangular part of this ditributed sub( a ) contains the upper triangular part of the matrix, and its strictly lower triangular part is not referenced sub( a ) contains the lower triangular part of the distribu- part of the matrix sub( a ) contains the upper triangular matrix, and the strictly lower triangular part of sub( a triangular part of the matrix sub( a ) contains the lower n-by-n upper triangular part of the matrix sub( a ) contains the upper triangular matrix to be inverted, and the strictly if uplo = 'l', the leading n-by-n lower triangular part of triangular part of sub( a ) contains the upper triangular matrix, and the strictly lower triangular part of sub( a triangular part of sub( a ) contains the lower triangular upper triangular part of the array t must contain the upper triangular matrix and the strictly lower triangular part o before entry with uplo = 'l' or 'l', the leading n by n upper triangular part of the array t must contain the upper triangular matrix and the strictly lower triangular part o before entry with uplo = 'l' or 'l', the leading n by n |
| stride stride the two integers npact (nu. of active processors) and npstr (stride between active processors) are used to control th the two integers npact (nu. of active processors) and npstr (stride between active processors) are used to control th the two integers npact (nu. of active processors) and npstr (stride between active processors) are used to control th the two integers npact (nu. of active processors) and npstr (stride between active processors) are used to control th |
| string string the character options to the subroutine name, concatenated into a single character string. for example, uplo = 'u' be specified as opts = 'utn'. |
| STRMM STRMM copy matrix h_i (the last bw cols of g_i) to af storage as per requirements of blas routine STRMM h_i^t to h_i. |
| STRMVT STRMVT STRMVT performs the matrix-vector operation x := t' *y, and w := t *z, |
| STRTRI STRTRI in the calling subroutine. for example, pjlaenv is used to retrieve the optimal blocksize for STRTRI as follows nb = pjlaenv( 1, 'strtri', uplo // diag, n, -1, -1, -1 ) |
| structure structure algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structure 3) backsubsitution phase: |
| Sturm Sturm the minimum absolute of a "pivot" in the "paranoid" implementation of the Sturm sequence loop. this must be a safe_min is at least the smallest number that can divide 1.0 pdlapdct counts the number of negative eigenvalues of (t - sigma i). this implementation of the Sturm sequence loop has conditionals i floating point number. pdlapdct will be referred to as the "paranoid" to 1 (in slmake.inc). the features of ieee arithmetic that are needed for the "fast" Sturm count are : (a) infinit point number is assumed be in the 32nd bit position the minimum absolute of a "pivot" in the "paranoid" implementation of the Sturm sequence loop. this must be a safe_min is at least the smallest number that can divide 1.0 pslapdct counts the number of negative eigenvalues of (t - sigma i). this implementation of the Sturm sequence loop has conditionals i floating point number. pslapdct will be referred to as the "paranoid" to 1 (in slmake.inc). the features of ieee arithmetic that are needed for the "fast" Sturm count are : (a) infinit point number is assumed be in the 32nd or 64th bit position |
| sub sub on entry, lda specifies the first dimension of a as declared in the calling (sub) program. lda must be at leas unchanged on exit. on entry, lda specifies the first dimension of a as declared in the calling (sub) program. lda must be at leas unchanged on exit. 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 the row index in the global array a indicating the first row of sub( a ) ja (global input) integer pcgeequ computes row and column scalings intended to equilibrate an m-by-n distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja:ja+n-1) an the column scale factors, chosen to try to make the largest entry in pcgehd2 reduces a complex general distributed matrix sub( a q' * sub( a ) * q = h, where pcgehrd reduces a complex general distributed matrix sub( a q' * sub( a ) * q = h, where pcgelq2 computes a lq factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = l * q notes pcgelqf computes a lq factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = l * q notes pcgels solves overdetermined or underdetermined complex linear systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) sub( a ). it is assumed that sub( a ) has full rank. pcgeql2 computes a ql factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * l notes pcgeqlf computes a ql factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * l notes pcgeqpf computes a qr factorization with column pivoting of a m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) sub( a ) * p = q * r. pcgeqr2 computes a qr factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * r notes pcgeqrf computes a qr factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * r notes in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). pcgerq2 computes a rq factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = r * q notes pcgerqf computes a rq factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = r * q notes sub( a ) * x = sub( b ) where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed the row index in the global array a indicating the first row of sub( a ) ja (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) pcgetf2 computes an lu factorization of a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) usin 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 factorization computed by pcgetrf. this method inverts u and then computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denote op( sub( a ) ) * x = sub( b with a general n-by-n distributed matrix sub( a ) using the lu pcggqrf computes a generalized qr factorization of an n-by-m matrix sub( a ) = a(ia:ia+n-1,ja:ja+m-1) an pcggrqf computes a generalized rq factorization of an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1 a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an of a complex generalized hermitian-definite eigenproblem, of the form sub( a )*x=(lambda)*sub( b )*x, sub( a )*sub( b )x=(lambda)*x, o here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to be in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an pchentrd reduces a complex hermitian matrix sub( a ) to hermitia q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pchetd2 reduces a complex hermitian matrix sub( a ) to hermitia q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pchetrd reduces a complex hermitian matrix sub( a ) to hermitia q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pchettrd reduces a complex hermitian matrix sub( a ) to hermitia q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). 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 uppe returns the matrices x and y which are needed to apply the transfor- pclacgv conjugates a complex vector of length n, sub( x ), wher x(ix:ix+n-1,jx) if incx = 1, and the row index in the global array v indicating the first row of sub( v ) jv (global input) integer distributed matrix b. no communication is performed, pclacp2 performs a local copy sub( a ) := sub( b ), where sub( a ) denote pclacp2 requires that only dimension of the matrix operands is distributed matrix b. no communication is performed, pclacpy performs a local copy sub( a ) := sub( b ), where sub( a ) denote n-by-(n-k+1) distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction i routine returns the matrices v and t which determine q as a block or the infinity norm, or the element of largest absolute value of a distributed matrix sub( a ) = a(ia:ia+m-1, ja:ja+n-1) pclange returns the value .. .. external subroutines . .. external functions .. .. .. external subroutines . .. external functions .. or inv( p ) to a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or colum or a column. the pivot vector should be aligned with the distributed pclapv2 applies either p (permutation matrix indicated by ipiv) or inv( p ) to a m-by-n distributed matrix sub( a ) denotin pivot vector should be aligned with the distributed matrix a. for 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 .. .. external subroutines . .. external functions .. pclarfb applies a complex block reflector q or its conjugate transpose q**h to a complex m-by-n distributed matrix sub( c .. .. external subroutines . .. external functions .. h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ), h' * h = i the row index in the global array v indicating the first row of sub( v ) jv (global input) integer .. .. external subroutines . .. external functions .. pclarzb applies a complex block reflector q or its conjugate transpose q**h to a complex m-by-n distributed matrix sub( c .. .. external subroutines . .. external functions .. the row index in the global array v indicating the first row of sub( v ) jv (global input) integer pclascl multiplies the m-by-n complex distributed matrix sub( a is done without over/underflow as long as the final result pclase2 initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. pclase2 requires that only dimension of the matrix pclaset initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ) ssq will then satisfy pclaswp performs a series of row or column interchanges on the distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1). on sub( a ). this routine assumes that the pivoting information has pclatra computes the trace of an n-by-n distributed matrix sub( a process of the grid. pclatrd reduces nb rows and columns of a complex hermitian distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) to comple q' * sub( a ) * q, and returns the matrices v and w which are pclatrz reduces the m-by-n ( m<=n ) complex upper trapezoidal matrix sub( a ) = [a(ia:ia+m-1,ja:ja+m-1) a(ia:ia+m-1,ja+n-l:ja+n-1) factor u or l is stored in the upper or lower triangular part of the matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) if uplo = 'u' or 'u' then the upper triangle of the result is stored, factor u or l is stored in the upper or lower triangular part of the distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) if uplo = 'u' or 'u' then the upper triangle of the result is stored, pcmax1 computes the global index of the maximum element in absolute value of a distributed vector sub( x ). the global index is returne the row index in the global array a indicating the first row of sub( a ) ja (global input) integer equilibrate a distributed hermitian positive definite matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition numbe factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri- in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). sub( a ) * x = sub( b ) where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is an n-by-n the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) pcpotf2 computes the cholesky factorization of a complex hermitian positive definite distributed matrix sub( a )=a(ia:ia+n-1,ja:ja+n-1) the factorization has the form pcpotrf computes the cholesky factorization of an n-by-n complex hermitian positive definite distributed matrix sub( a ) denotin 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. sub( a ) * x = sub( b pcsrscl multiplies an n-element complex distributed vector sub( x ) by the real scalar 1/a. this is done without overflow o underflow. the row index in the global array a indicating the first row of sub( a ) ja (global input) integer in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). pctrti2 computes the inverse of a complex upper or lower triangular block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should b pctrtri computes the inverse of a upper or lower triangular distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ) o sub( a )**h * x = sub( b ), pctzrzf reduces the m-by-n ( m<=n ) complex upper trapezoidal matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper triangular form by mean the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer pcunm2l overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pcunm2r overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' if vect = 'q', pcunmbr overwrites the general complex distributed m-by-n matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pcunmhr overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pcunml2 overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pcunmlq overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pcunmql overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pcunmqr overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pcunmr2 overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pcunmr3 overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pcunmrq overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pcunmrz overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pcunmtr overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' 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 the row index in the global array a indicating the first row of sub( a ) ja (global input) integer pdgeequ computes row and column scalings intended to equilibrate an m-by-n distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja:ja+n-1) an the column scale factors, chosen to try to make the largest entry in pdgehd2 reduces a real general distributed matrix sub( a tion: q' * sub( a ) * q = h, where pdgehrd reduces a real general distributed matrix sub( a tion: q' * sub( a ) * q = h, where pdgelq2 computes a lq factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = l * q notes pdgelqf computes a lq factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = l * q notes pdgels solves overdetermined or underdetermined real linear systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) assumed that sub( a ) has full rank. pdgeql2 computes a ql factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * l notes pdgeqlf computes a ql factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * l notes pdgeqpf computes a qr factorization with column pivoting of a m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) sub( a ) * p = q * r. pdgeqr2 computes a qr factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * r notes pdgeqrf computes a qr factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * r notes in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). pdgerq2 computes a rq factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = r * q notes pdgerqf computes a rq factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = r * q notes sub( a ) * x = sub( b ) where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed the row index in the global array a indicating the first row of sub( a ) ja (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) pdgetf2 computes an lu factorization of a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) usin 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 factorization computed by pdgetrf. this method inverts u and then computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denote op( sub( a ) ) * x = sub( b with a general n-by-n distributed matrix sub( a ) using the lu pdggqrf computes a generalized qr factorization of an n-by-m matrix sub( a ) = a(ia:ia+n-1,ja:ja+m-1) an pdggrqf computes a generalized rq factorization of an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1 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 uppe and returns the matrices x and y which are needed to apply the the row index in the global array v indicating the first row of sub( v ) jv (global input) integer distributed matrix b. no communication is performed, pdlacp2 performs a local copy sub( a ) := sub( b ), where sub( a ) denote pdlacp2 requires that only dimension of the matrix operands is distributed matrix b. no communication is performed, pdlacpy performs a local copy sub( a ) := sub( b ), where sub( a ) denote the location of the last eigenvalue in the leading sub-matrix n1 (input) integer the location of the last eigenvalue in the leading sub-matrix arithmetic. it will work on machines with a guard digit in add/subtract, or on those binary machines without guard digit it could conceivably fail on hexadecimal or decimal machines distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction is performed by an orthogo matrices v and t which determine q as a block reflector i - v*t*v', or the infinity norm, or the element of largest absolute value of a distributed matrix sub( a ) = a(ia:ia+m-1, ja:ja+n-1) pdlange returns the value .. .. external subroutines . .. external functions .. or inv( p ) to a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or colum or a column. the pivot vector should be aligned with the distributed pdlapv2 applies either p (permutation matrix indicated by ipiv) or inv( p ) to a m-by-n distributed matrix sub( a ) denotin pivot vector should be aligned with the distributed matrix a. for 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 .. .. external subroutines . .. external functions .. pdlarfb applies a real block reflector q or its transpose q**t to a real distributed m-by-n matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1 h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ), h' * h = i the row index in the global array v indicating the first row of sub( v ) jv (global input) integer .. .. external subroutines . .. external functions .. pdlarzb applies a real block reflector q or its transpose q**t to a real distributed m-by-n matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1 the row index in the global array v indicating the first row of sub( v ) jv (global input) integer pdlascl multiplies the m-by-n real distributed matrix sub( a is done without over/underflow as long as the final result pdlase2 initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. pdlase2 requires that only dimension of the matrix pdlaset initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. the number of columns to be operated on i.e the number of columns of the distributed submatrix sub( q ). n >= 0 d (global input/output) double precision array, dimmension (n) where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ) value pdlaswp performs a series of row or column interchanges on the distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1). on sub( a ). this routine assumes that the pivoting information has pdlatra computes the trace of an n-by-n distributed matrix sub( a process of the grid. pdlatrd reduces nb rows and columns of a real symmetric distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) to symmetric tridiagona and returns the matrices v and w which are needed to apply the pdlatrz reduces the m-by-n ( m<=n ) real upper trapezoidal matrix sub( a ) = [ a(ia:ia+m-1,ja:ja+m-1) a(ia:ia+m-1,ja+n-l:ja+n-1) ] t factor u or l is stored in the upper or lower triangular part of the matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) if uplo = 'u' or 'u' then the upper triangle of the result is stored, factor u or l is stored in the upper or lower triangular part of the distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) if uplo = 'u' or 'u' then the upper triangle of the result is stored, the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer pdorm2l overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pdorm2r overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' if vect = 'q', pdormbr overwrites the general real distributed m-by-n matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pdormhr overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pdorml2 overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pdormlq overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pdormql overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pdormqr overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pdormr2 overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pdormr3 overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pdormrq overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pdormrz overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pdormtr overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' the row index in the global array a indicating the first row of sub( a ) ja (global input) integer equilibrate a distributed symmetric positive definite matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition numbe factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri- in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). sub( a ) * x = sub( b ) where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is an n-by-n the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) pdpotf2 computes the cholesky factorization of a real symmetric positive definite distributed matrix sub( a )=a(ia:ia+n-1,ja:ja+n-1) the factorization has the form pdpotrf computes the cholesky factorization of an n-by-n real symmetric positive definite distributed matrix sub( a ) denotin 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. sub( a ) * x = sub( b pdrscl multiplies an n-element real distributed vector sub( x ) b long as the final result sub( x )/a does not overflow or underflow. the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/workspace) block cyclic double precision array, in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an of a real generalized sy-definite eigenproblem, of the form sub( a )*x=(lambda)*sub( b )*x, sub( a )*sub( b )x=(lambda)*x, o here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to be in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an pdsyntrd reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pdsytd2 reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pdsytrd reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pdsyttrd reduces a complex hermitian matrix sub( a ) to hermitia q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). the row index in the global array a indicating the first row of sub( a ) ja (global input) integer in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). pdtrti2 computes the inverse of a real upper or lower triangular block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should b pdtrtri computes the inverse of a upper or lower triangular distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ) where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a triangular pdtzrzf reduces the m-by-n ( m<=n ) real upper trapezoidal matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper triangular form by mean pdzsum1 returns the sum of absolute values of a complex distributed vector sub( x ) in asum where sub( x ) denotes x(ix:ix+n-1,jx:jx), if incx = 1, pscsum1 returns the sum of absolute values of a complex distributed vector sub( x ) in asum where sub( x ) denotes x(ix:ix+n-1,jx:jx), if incx = 1, 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 the row index in the global array a indicating the first row of sub( a ) ja (global input) integer psgeequ computes row and column scalings intended to equilibrate an m-by-n distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja:ja+n-1) an the column scale factors, chosen to try to make the largest entry in psgehd2 reduces a real general distributed matrix sub( a tion: q' * sub( a ) * q = h, where psgehrd reduces a real general distributed matrix sub( a tion: q' * sub( a ) * q = h, where psgelq2 computes a lq factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = l * q notes psgelqf computes a lq factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = l * q notes psgels solves overdetermined or underdetermined real linear systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) assumed that sub( a ) has full rank. psgeql2 computes a ql factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * l notes psgeqlf computes a ql factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * l notes psgeqpf computes a qr factorization with column pivoting of a m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) sub( a ) * p = q * r. psgeqr2 computes a qr factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * r notes psgeqrf computes a qr factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * r notes in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). psgerq2 computes a rq factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = r * q notes psgerqf computes a rq factorization of a real distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = r * q notes sub( a ) * x = sub( b ) where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed the row index in the global array a indicating the first row of sub( a ) ja (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) psgetf2 computes an lu factorization of a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) usin 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 factorization computed by psgetrf. this method inverts u and then computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denote op( sub( a ) ) * x = sub( b with a general n-by-n distributed matrix sub( a ) using the lu psggqrf computes a generalized qr factorization of an n-by-m matrix sub( a ) = a(ia:ia+n-1,ja:ja+m-1) an psggrqf computes a generalized rq factorization of an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1 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 uppe and returns the matrices x and y which are needed to apply the the row index in the global array v indicating the first row of sub( v ) jv (global input) integer distributed matrix b. no communication is performed, pslacp2 performs a local copy sub( a ) := sub( b ), where sub( a ) denote pslacp2 requires that only dimension of the matrix operands is distributed matrix b. no communication is performed, pslacpy performs a local copy sub( a ) := sub( b ), where sub( a ) denote the location of the last eigenvalue in the leading sub-matrix n1 (input) integer the location of the last eigenvalue in the leading sub-matrix arithmetic. it will work on machines with a guard digit in add/subtract, or on those binary machines without guard digit it could conceivably fail on hexadecimal or decimal machines distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction is performed by an orthogo matrices v and t which determine q as a block reflector i - v*t*v', or the infinity norm, or the element of largest absolute value of a distributed matrix sub( a ) = a(ia:ia+m-1, ja:ja+n-1) pslange returns the value .. .. external subroutines . .. external functions .. or inv( p ) to a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or colum or a column. the pivot vector should be aligned with the distributed pslapv2 applies either p (permutation matrix indicated by ipiv) or inv( p ) to a m-by-n distributed matrix sub( a ) denotin pivot vector should be aligned with the distributed matrix a. for 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 .. .. external subroutines . .. external functions .. pslarfb applies a real block reflector q or its transpose q**t to a real distributed m-by-n matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1 h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ), h' * h = i the row index in the global array v indicating the first row of sub( v ) jv (global input) integer .. .. external subroutines . .. external functions .. pslarzb applies a real block reflector q or its transpose q**t to a real distributed m-by-n matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1 the row index in the global array v indicating the first row of sub( v ) jv (global input) integer pslascl multiplies the m-by-n real distributed matrix sub( a is done without over/underflow as long as the final result pslase2 initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. pslase2 requires that only dimension of the matrix pslaset initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. the number of columns to be operated on i.e the number of columns of the distributed submatrix sub( q ). n >= 0 d (global input/output) real array, dimmension (n) where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ) value pslaswp performs a series of row or column interchanges on the distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1). on sub( a ). this routine assumes that the pivoting information has pslatra computes the trace of an n-by-n distributed matrix sub( a process of the grid. pslatrd reduces nb rows and columns of a real symmetric distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) to symmetric tridiagona and returns the matrices v and w which are needed to apply the pslatrz reduces the m-by-n ( m<=n ) real upper trapezoidal matrix sub( a ) = [ a(ia:ia+m-1,ja:ja+m-1) a(ia:ia+m-1,ja+n-l:ja+n-1) ] t factor u or l is stored in the upper or lower triangular part of the matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) if uplo = 'u' or 'u' then the upper triangle of the result is stored, factor u or l is stored in the upper or lower triangular part of the distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) if uplo = 'u' or 'u' then the upper triangle of the result is stored, the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer psorm2l overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' psorm2r overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' if vect = 'q', psormbr overwrites the general real distributed m-by-n matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' psormhr overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' psorml2 overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' psormlq overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' psormql overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' psormqr overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' psormr2 overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' psormr3 overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' psormrq overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' psormrz overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' psormtr overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' the row index in the global array a indicating the first row of sub( a ) ja (global input) integer equilibrate a distributed symmetric positive definite matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition numbe factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri- in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). sub( a ) * x = sub( b ) where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is an n-by-n the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) pspotf2 computes the cholesky factorization of a real symmetric positive definite distributed matrix sub( a )=a(ia:ia+n-1,ja:ja+n-1) the factorization has the form pspotrf computes the cholesky factorization of an n-by-n real symmetric positive definite distributed matrix sub( a ) denotin 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. sub( a ) * x = sub( b psrscl multiplies an n-element real distributed vector sub( x ) b long as the final result sub( x )/a does not overflow or underflow. the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/workspace) block cyclic real array, in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an of a real generalized sy-definite eigenproblem, of the form sub( a )*x=(lambda)*sub( b )*x, sub( a )*sub( b )x=(lambda)*x, o here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to be in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an pssyntrd reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pssytd2 reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pssytrd reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pssyttrd reduces a complex hermitian matrix sub( a ) to hermitia q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). the row index in the global array a indicating the first row of sub( a ) ja (global input) integer in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). pstrti2 computes the inverse of a real upper or lower triangular block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should b pstrtri computes the inverse of a upper or lower triangular distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ) where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a triangular pstzrzf reduces the m-by-n ( m<=n ) real upper trapezoidal matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper triangular form by mean pzdrscl multiplies an n-element complex distributed vector sub( x ) by the real scalar 1/a. this is done without overflow o underflow. 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 the row index in the global array a indicating the first row of sub( a ) ja (global input) integer pzgeequ computes row and column scalings intended to equilibrate an m-by-n distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja:ja+n-1) an the column scale factors, chosen to try to make the largest entry in pzgehd2 reduces a complex general distributed matrix sub( a q' * sub( a ) * q = h, where pzgehrd reduces a complex general distributed matrix sub( a q' * sub( a ) * q = h, where pzgelq2 computes a lq factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = l * q notes pzgelqf computes a lq factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = l * q notes pzgels solves overdetermined or underdetermined complex linear systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) sub( a ). it is assumed that sub( a ) has full rank. pzgeql2 computes a ql factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * l notes pzgeqlf computes a ql factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * l notes pzgeqpf computes a qr factorization with column pivoting of a m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) sub( a ) * p = q * r. pzgeqr2 computes a qr factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * r notes pzgeqrf computes a qr factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = q * r notes in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). pzgerq2 computes a rq factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = r * q notes pzgerqf computes a rq factorization of a complex distributed m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) = r * q notes sub( a ) * x = sub( b ) where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed the row index in the global array a indicating the first row of sub( a ) ja (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) pzgetf2 computes an lu factorization of a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) usin 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 factorization computed by pzgetrf. this method inverts u and then computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denote op( sub( a ) ) * x = sub( b with a general n-by-n distributed matrix sub( a ) using the lu pzggqrf computes a generalized qr factorization of an n-by-m matrix sub( a ) = a(ia:ia+n-1,ja:ja+m-1) an pzggrqf computes a generalized rq factorization of an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1 a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an of a complex generalized hermitian-definite eigenproblem, of the form sub( a )*x=(lambda)*sub( b )*x, sub( a )*sub( b )x=(lambda)*x, o here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to be in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) an pzhentrd reduces a complex hermitian matrix sub( a ) to hermitia q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pzhetd2 reduces a complex hermitian matrix sub( a ) to hermitia q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pzhetrd reduces a complex hermitian matrix sub( a ) to hermitia q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pzhettrd reduces a complex hermitian matrix sub( a ) to hermitia q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). 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 uppe returns the matrices x and y which are needed to apply the transfor- pzlacgv conjugates a complex vector of length n, sub( x ), wher x(ix:ix+n-1,jx) if incx = 1, and the row index in the global array v indicating the first row of sub( v ) jv (global input) integer distributed matrix b. no communication is performed, pzlacp2 performs a local copy sub( a ) := sub( b ), where sub( a ) denote pzlacp2 requires that only dimension of the matrix operands is distributed matrix b. no communication is performed, pzlacpy performs a local copy sub( a ) := sub( b ), where sub( a ) denote n-by-(n-k+1) distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction i routine returns the matrices v and t which determine q as a block or the infinity norm, or the element of largest absolute value of a distributed matrix sub( a ) = a(ia:ia+m-1, ja:ja+n-1) pzlange returns the value .. .. external subroutines . .. external functions .. .. .. external subroutines . .. external functions .. or inv( p ) to a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or colum or a column. the pivot vector should be aligned with the distributed pzlapv2 applies either p (permutation matrix indicated by ipiv) or inv( p ) to a m-by-n distributed matrix sub( a ) denotin pivot vector should be aligned with the distributed matrix a. for 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 .. .. external subroutines . .. external functions .. pzlarfb applies a complex block reflector q or its conjugate transpose q**h to a complex m-by-n distributed matrix sub( c .. .. external subroutines . .. external functions .. h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ), h' * h = i the row index in the global array v indicating the first row of sub( v ) jv (global input) integer .. .. external subroutines . .. external functions .. pzlarzb applies a complex block reflector q or its conjugate transpose q**h to a complex m-by-n distributed matrix sub( c .. .. external subroutines . .. external functions .. the row index in the global array v indicating the first row of sub( v ) jv (global input) integer pzlascl multiplies the m-by-n complex distributed matrix sub( a is done without over/underflow as long as the final result pzlase2 initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. pzlase2 requires that only dimension of the matrix pzlaset initializes an m-by-n distributed matrix sub( a ) denotin offdiagonals. where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ) ssq will then satisfy pzlaswp performs a series of row or column interchanges on the distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1). on sub( a ). this routine assumes that the pivoting information has pzlatra computes the trace of an n-by-n distributed matrix sub( a process of the grid. pzlatrd reduces nb rows and columns of a complex hermitian distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) to comple q' * sub( a ) * q, and returns the matrices v and w which are pzlatrz reduces the m-by-n ( m<=n ) complex upper trapezoidal matrix sub( a ) = [a(ia:ia+m-1,ja:ja+m-1) a(ia:ia+m-1,ja+n-l:ja+n-1) factor u or l is stored in the upper or lower triangular part of the matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) if uplo = 'u' or 'u' then the upper triangle of the result is stored, factor u or l is stored in the upper or lower triangular part of the distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) if uplo = 'u' or 'u' then the upper triangle of the result is stored, pzmax1 computes the global index of the maximum element in absolute value of a distributed vector sub( x ). the global index is returne the row index in the global array a indicating the first row of sub( a ) ja (global input) integer equilibrate a distributed hermitian positive definite matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition numbe factors, s(i) = 1/sqrt(a(i,i)), chosen so that the scaled distri- in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). sub( a ) * x = sub( b ) where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is an n-by-n the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) pzpotf2 computes the cholesky factorization of a complex hermitian positive definite distributed matrix sub( a )=a(ia:ia+n-1,ja:ja+n-1) the factorization has the form pzpotrf computes the cholesky factorization of an n-by-n complex hermitian positive definite distributed matrix sub( a ) denotin 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. sub( a ) * x = sub( b the row index in the global array a indicating the first row of sub( a ) ja (global input) integer in the following comments, sub( a ), sub( x ) and sub( b ) denot b(ib:ib+n-1,jb:jb+nrhs-1). pztrti2 computes the inverse of a complex upper or lower triangular block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should b pztrtri computes the inverse of a upper or lower triangular distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ) o sub( a )**h * x = sub( b ), pztzrzf reduces the m-by-n ( m<=n ) complex upper trapezoidal matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) to upper triangular form by mean the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer pzunm2l overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pzunm2r overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' if vect = 'q', pzunmbr overwrites the general complex distributed m-by-n matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pzunmhr overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pzunml2 overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pzunmlq overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pzunmql overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pzunmqr overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pzunmr2 overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pzunmr3 overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pzunmrq overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pzunmrz overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' pzunmtr overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) wit side = 'l' side = 'r' on entry, lda specifies the first dimension of a as declared in the calling (sub) program. lda must be at leas unchanged on exit. on entry, lda specifies the first dimension of a as declared in the calling (sub) program. lda must be at leas unchanged on exit. |
| subclass subclass because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, because vectors may be viewed as a subclass of matrices, |
| subdiagonal subdiagonal zero the subdiagonal elements of the work array work3 dl (input/output) complex array, dimension (n-1) on entry, dl must contain the (n-1) subdiagonal elements o on exit, dl is overwritten by the (n-1) multipliers that submatrix of order 1 or 2 splits off at the bottom because a subdiagonal element has become negligible clamsh sends multiple shifts through a small (single node) matrix to see how consecutive small subdiagonal elements are modified b that can be sent through. uplo (input) character*1 specifies whether the superdiagonal or the subdiagonal factorization: skip the current step: the subdiagonal info is just noise zero the subdiagonal elements of the work array work3 dl (input/output) complex array, dimension (n-1) on entry, dl must contain the (n-1) subdiagonal elements o on exit, dl is overwritten by the (n-1) multipliers that dlamsh sends multiple shifts through a small (single node) matrix to see how consecutive small subdiagonal elements are modified b that can be sent through. complex are together. this way one can employ 2x2 shifts easily since every 2nd subdiagonal is guaranteed to be zero look for small subdiagonal element elementary reflectors. if m < n, the diagonal and the first subdiagonal are overwritten with the lower bidiagona array tauq, represent the unitary matrix q as a product of elementary reflectors. if m < n, the diagonal and the first subdiagonal are overwritten with the lower bidiagona array tauq, represent the unitary matrix q as a product of general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) ar ments below the first subdiagonal, with the array tau, repre- general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) ar ments below the first subdiagonal, with the array tau, repre- m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the unitary matrix q as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the unitary matrix q as a product of n by n upper triangular matrix t; if n > p, the elements on and above the (n-p)-th subdiagonal contain the n by p uppe taub, represent the unitary matrix z as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe taua, represent the unitary matrix q as a product of product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, pclaconsb looks for two consecutive small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a submatrix of order 1 or 2 splits off at the bottom because a subdiagonal element has become negligible n-by-(n-k+1) distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction i routine returns the matrices v and t which determine q as a block pclasmsub looks for a small subdiagonal element from the botto of elementary reflectors. if m < n, the diagonal and the first subdiagonal are overwritten with the lower bidiagona array tauq, represent the orthogonal matrix q as a product of of elementary reflectors. if m < n, the diagonal and the first subdiagonal are overwritten with the lower bidiagona array tauq, represent the orthogonal matrix q as a product of general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) ar ments below the first subdiagonal, with the array tau, repre- general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) ar ments below the first subdiagonal, with the array tau, repre- m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the orthogonal matrix q as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the orthogonal matrix q as a product of n by n upper triangular matrix t; if n > p, the elements on and above the (n-p)-th subdiagonal contain the n by p uppe taub, represent the orthogonal matrix z as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe taua, represent the orthogonal matrix q as a product of pdlaconsb looks for two consecutive small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a e (global input/output) double precision array, dimension (n-1) on entry, the subdiagonal elements of the tridiagonal matrix rho (input) double precision the subdiagonal entry used to create the rank-1 modification work (local workspace/output) double precision array, submatrix of order 1 or 2 splits off at the bottom because a subdiagonal element has become negligible distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction is performed by an orthogo matrices v and t which determine q as a block reflector i - v*t*v', pdlasmsub looks for a small subdiagonal element from the botto e (global input/output) double precision array, dimension (n-1) on entry, the subdiagonal elements of the tridiagonal matrix product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, of elementary reflectors. if m < n, the diagonal and the first subdiagonal are overwritten with the lower bidiagona array tauq, represent the orthogonal matrix q as a product of of elementary reflectors. if m < n, the diagonal and the first subdiagonal are overwritten with the lower bidiagona array tauq, represent the orthogonal matrix q as a product of general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) ar ments below the first subdiagonal, with the array tau, repre- general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) ar ments below the first subdiagonal, with the array tau, repre- m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the orthogonal matrix q as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the orthogonal matrix q as a product of n by n upper triangular matrix t; if n > p, the elements on and above the (n-p)-th subdiagonal contain the n by p uppe taub, represent the orthogonal matrix z as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe taua, represent the orthogonal matrix q as a product of pslaconsb looks for two consecutive small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a e (global input/output) real array, dimension (n-1) on entry, the subdiagonal elements of the tridiagonal matrix rho (input) real the subdiagonal entry used to create the rank-1 modification work (local workspace/output) real array, submatrix of order 1 or 2 splits off at the bottom because a subdiagonal element has become negligible distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction is performed by an orthogo matrices v and t which determine q as a block reflector i - v*t*v', pslasmsub looks for a small subdiagonal element from the botto e (global input/output) real array, dimension (n-1) on entry, the subdiagonal elements of the tridiagonal matrix product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, elementary reflectors. if m < n, the diagonal and the first subdiagonal are overwritten with the lower bidiagona array tauq, represent the unitary matrix q as a product of elementary reflectors. if m < n, the diagonal and the first subdiagonal are overwritten with the lower bidiagona array tauq, represent the unitary matrix q as a product of general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) ar ments below the first subdiagonal, with the array tau, repre- general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) ar ments below the first subdiagonal, with the array tau, repre- m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the unitary matrix q as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the unitary matrix q as a product of n by n upper triangular matrix t; if n > p, the elements on and above the (n-p)-th subdiagonal contain the n by p uppe taub, represent the unitary matrix z as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe taua, represent the unitary matrix q as a product of product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, product of elementary reflectors; if uplo = 'l', the diagonal and first subdiagonal of sub( a ) are overwritten by th elements below the first subdiagonal, with the array tau, pzlaconsb looks for two consecutive small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a submatrix of order 1 or 2 splits off at the bottom because a subdiagonal element has become negligible n-by-(n-k+1) distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction i routine returns the matrices v and t which determine q as a block pzlasmsub looks for a small subdiagonal element from the botto zero the subdiagonal elements of the work array work3 dl (input/output) complex array, dimension (n-1) on entry, dl must contain the (n-1) subdiagonal elements o on exit, dl is overwritten by the (n-1) multipliers that slamsh sends multiple shifts through a small (single node) matrix to see how consecutive small subdiagonal elements are modified b that can be sent through. complex are together. this way one can employ 2x2 shifts easily since every 2nd subdiagonal is guaranteed to be zero look for small subdiagonal element zero the subdiagonal elements of the work array work3 dl (input/output) complex array, dimension (n-1) on entry, dl must contain the (n-1) subdiagonal elements o on exit, dl is overwritten by the (n-1) multipliers that submatrix of order 1 or 2 splits off at the bottom because a subdiagonal element has become negligible zlamsh sends multiple shifts through a small (single node) matrix to see how consecutive small subdiagonal elements are modified b that can be sent through. uplo (input) character*1 specifies whether the superdiagonal or the subdiagonal factorization: skip the current step: the subdiagonal info is just noise |
| subdiagonals subdiagonals kl (input) integer the number of subdiagonals within the band of a. kl >= 0 ku (input) integer kl (input) integer the number of subdiagonals within the band of a. kl >= 0 ku (input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer loop passes over the data and searches for two consecutive small subdiagonals notes: bw (global input) integer number of subdiagonals in l or u. 0 <= bw <= n- nrhs (global input) integer bw (global input) integer number of subdiagonals in l or u. 0 <= bw <= n- nrhs (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer loop passes over the data and searches for two consecutive small subdiagonals notes: bw (global input) integer number of subdiagonals in l or u. 0 <= bw <= n- nrhs (global input) integer bw (global input) integer number of subdiagonals in l or u. 0 <= bw <= n- nrhs (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer loop passes over the data and searches for two consecutive small subdiagonals notes: bw (global input) integer number of subdiagonals in l or u. 0 <= bw <= n- nrhs (global input) integer bw (global input) integer number of subdiagonals in l or u. 0 <= bw <= n- nrhs (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer bwl (global input) integer number of subdiagonals. 0 <= bwl <= n- bwu (global input) integer loop passes over the data and searches for two consecutive small subdiagonals notes: bw (global input) integer number of subdiagonals in l or u. 0 <= bw <= n- nrhs (global input) integer bw (global input) integer number of subdiagonals in l or u. 0 <= bw <= n- nrhs (global input) integer kl (input) integer the number of subdiagonals within the band of a. kl >= 0 ku (input) integer kl (input) integer the number of subdiagonals within the band of a. kl >= 0 ku (input) integer |
| subdivided subdivided each of these three parts are further subdivided into a.) work at the start of a border when each of these three parts are further subdivided into a.) work at the start of a border when each of these three parts are further subdivided into a.) work at the start of a border when each of these three parts are further subdivided into a.) work at the start of a border when |
| submatrices submatrices the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the number of right hand sides, i.e. the number of columns of the distributed submatrices sub( b ) and x. nrhs >= 0 a (local input/local output) complex pointer into the the distributed submatrices op( a ) and op( af ) (respectivel same processes. these conditions ensure that sub( a ) and sub( af ) the number of right-hand sides, i.e., the number of columns of the distributed submatrices b(ib:ib+n-1,jb:jb+nrhs-1) an the number of rows to be operated on i.e the number of rows of the distributed submatrices sub( a ) and sub( b ). n >= 0 m (global input) integer the number of columns to be operated on i.e the number of columns of the distributed submatrices sub( a ) and sub( b ) the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices sub( a ), sub( z ) must verif should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*), c(ic:ic+m-1,jc:jc+n-1) namely the following expressions should be true: the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the distributed submatrices op( a ) and op( af ) (respectivel same processes. these conditions ensure that sub( a ) and sub( af ) the number of right hand sides, i.e., the number of columns of the distributed submatrices b and x. nrhs >= 0 a (local input/local output) complex pointer into the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: isplit (global input) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), the distributed submatrices sub( x ) and sub( b ) should b ensure that sub( x ) and sub( b ) are "perfectly" aligned. the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the number of right hand sides, i.e. the number of columns of the distributed submatrices sub( b ) and x. nrhs >= 0 a (local input/local output) double precision pointer into the the distributed submatrices op( a ) and op( af ) (respectivel same processes. these conditions ensure that sub( a ) and sub( af ) the number of right-hand sides, i.e., the number of columns of the distributed submatrices b(ib:ib+n-1,jb:jb+nrhs-1) an the number of rows to be operated on i.e the number of rows of the distributed submatrices sub( a ) and sub( b ). n >= 0 m (global input) integer the number of columns to be operated on i.e the number of columns of the distributed submatrices sub( a ) and sub( b ) d (input/output) double precision array, dimension (n) on entry, d contains the eigenvalues of the two submatrices t on exit, d contains the trailing (n-k) updated eigenvalues d (input/output) double precision array, dimension (n) on entry, d contains the eigenvalues of the two submatrices t on exit, d contains the trailing (n-k) updated eigenvalues skip small submatrices if ( m .ge. i - 5 ) the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the distributed submatrices op( a ) and op( af ) (respectivel same processes. these conditions ensure that sub( a ) and sub( af ) the number of right hand sides, i.e., the number of columns of the distributed submatrices b and x. nrhs >= 0 a (local input/local output) double precision pointer into the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: isplit (global output) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), isplit (global input) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), the distributed submatrices a(ia:*, ja:*) and z(iz:iz+m-1,jz:jz+n-1 expressions should be true: the distributed submatrices sub( a ), sub( z ) must verif should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*), c(ic:ic+m-1,jc:jc+n-1) namely the following expressions should be true: the distributed submatrices sub( x ) and sub( b ) should b ensure that sub( x ) and sub( b ) are "perfectly" aligned. the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the number of right hand sides, i.e. the number of columns of the distributed submatrices sub( b ) and x. nrhs >= 0 a (local input/local output) real pointer into the the distributed submatrices op( a ) and op( af ) (respectivel same processes. these conditions ensure that sub( a ) and sub( af ) the number of right-hand sides, i.e., the number of columns of the distributed submatrices b(ib:ib+n-1,jb:jb+nrhs-1) an the number of rows to be operated on i.e the number of rows of the distributed submatrices sub( a ) and sub( b ). n >= 0 m (global input) integer the number of columns to be operated on i.e the number of columns of the distributed submatrices sub( a ) and sub( b ) d (input/output) real array, dimension (n) on entry, d contains the eigenvalues of the two submatrices t on exit, d contains the trailing (n-k) updated eigenvalues d (input/output) real array, dimension (n) on entry, d contains the eigenvalues of the two submatrices t on exit, d contains the trailing (n-k) updated eigenvalues skip small submatrices if ( m .ge. i - 5 ) the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the distributed submatrices op( a ) and op( af ) (respectivel same processes. these conditions ensure that sub( a ) and sub( af ) the number of right hand sides, i.e., the number of columns of the distributed submatrices b and x. nrhs >= 0 a (local input/local output) real pointer into the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: isplit (global output) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), isplit (global input) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), the distributed submatrices a(ia:*, ja:*) and z(iz:iz+m-1,jz:jz+n-1 expressions should be true: the distributed submatrices sub( a ), sub( z ) must verif should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*), c(ic:ic+m-1,jc:jc+n-1) namely the following expressions should be true: the distributed submatrices sub( x ) and sub( b ) should b ensure that sub( x ) and sub( b ) are "perfectly" aligned. the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the number of right hand sides, i.e. the number of columns of the distributed submatrices sub( b ) and x. nrhs >= 0 a (local input/local output) complex*16 pointer into the the distributed submatrices op( a ) and op( af ) (respectivel same processes. these conditions ensure that sub( a ) and sub( af ) the number of right-hand sides, i.e., the number of columns of the distributed submatrices b(ib:ib+n-1,jb:jb+nrhs-1) an the number of rows to be operated on i.e the number of rows of the distributed submatrices sub( a ) and sub( b ). n >= 0 m (global input) integer the number of columns to be operated on i.e the number of columns of the distributed submatrices sub( a ) and sub( b ) the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices sub( a ), sub( z ) must verif should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*), c(ic:ic+m-1,jc:jc+n-1) namely the following expressions should be true: the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices v(iv:*, jv:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the distributed submatrices op( a ) and op( af ) (respectivel same processes. these conditions ensure that sub( a ) and sub( af ) the number of right hand sides, i.e., the number of columns of the distributed submatrices b and x. nrhs >= 0 a (local input/local output) complex*16 pointer into the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: the matrices factored on each processor. the factors of these submatrices overwrite the corresponding parts of 2) reduced system phase: isplit (global input) integer array, dimension (n) the splitting points, at which t breaks up into submatrices the second of rows/columns isplit(1)+1 through isplit(2), the distributed submatrices sub( x ) and sub( b ) should b ensure that sub( x ) and sub( b ) are "perfectly" aligned. the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: the distributed submatrices a(ia:*, ja:*) and c(ic:ic+m-1,jc:jc+n-1 expressions should be true: |
| submatrix submatrix ihi to ilo in steps of 1 or 2. each iteration of the loop works with the active submatrix in rows and columns l to i h(l,l-1) is negligible so that the matrix splits. scale submatrix in rows and columns l to len the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 ilo (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 ilo (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of columns to be operated on i.e the number of columns of the distributed submatrix sub( a ). m >= 0 p (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 p (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex pointer into the the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the global location of the bottom of the unreduced submatrix of a the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer array into a local replicated array or vise versa. notice that the entire submatrix that is copied gets placed on one node o can receive, or just one row or column of nodes. the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer z's global row index, which points to the beginning of the submatrix which is to be operated on jz (global input) integer ihi to ilo in steps of our schur block size (<=2*iblk). each iteration of the loop works with the active submatrix in row converged. either l = ilo or the global a(l,l-1) is negligible the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ) a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). when m = 0, pclang the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (input/output) complex pointer into the local the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the global location of the bottom of the unreduced submatrix of a the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 a (local input) complex pointer into the local memory the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nb (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bw (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bw (global input) integer the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 a (local input) complex pointer into the local memory to an the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer ix (global input) pointer to integer the global row index of the submatrix of the distribute iblock (global input) integer array, dimension (n) the submatrix indices associated with the correspondin first submatrix from the top, 2 for those belonging to the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex pointer into the the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 ilo (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 ilo (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) double precision pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of columns to be operated on i.e the number of columns of the distributed submatrix sub( a ). m >= 0 p (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 p (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the global location of the bottom of the unreduced submatrix of a the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer array into a local replicated array or vise versa. notice that the entire submatrix that is copied gets placed on one node o can receive, or just one row or column of nodes. the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer q's global row index, which points to the beginning of the submatrix which is to be operated on jq (global input) integer q's global row/col index, which points to the beginning of the submatrix which is to be operated on q (local output) double precision array, the total number of columns over which the distributed submatrix is distributed indx (workspace) integer array, dimension (n) the total number of columns over which the distributed submatrix is distributed info (output) integer z's global row index, which points to the beginning of the submatrix which is to be operated on jz (global input) integer ihi to ilo in steps of our schur block size (<=2*iblk). each iteration of the loop works with the active submatrix in row converged. either l = ilo or the global a(l,l-1) is negligible the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ) a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). when m = 0, pdlang the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (input/output) double precision pointer into the local the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the global location of the bottom of the unreduced submatrix of a the number of columns to be operated on i.e the number of columns of the distributed submatrix sub( q ). n >= 0 d (global input/output) double precision array, dimmension (n) the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 a (local input) double precision pointer into the local memory the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nb (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bw (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bw (global input) integer the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 a (local input) double precision pointer into the local memory the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) double precision pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) double precision pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) double precision pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer ix (global input) pointer to integer the global row index of the submatrix of the distribute the splitting points, at which t breaks up into submatrices. the first submatrix consists of rows/columns 1 to isplit(1) etc., and the nsplit-th consists of rows/columns q's global row index, which points to the beginning of the submatrix which is to be operated on jq (global input) integer iblock (global input) integer array, dimension (n) the submatrix indices associated with the correspondin first submatrix from the top, 2 for those belonging to a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/workspace) block cyclic double precision array, a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) double precision pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) double precision pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) double precision pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) double precision pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) double precision pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) double precision pointer into the the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer ix (global input) pointer to integer the global row index of the submatrix of the distribute ix (global input) pointer to integer the global row index of the submatrix of the distribute the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 ilo (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 ilo (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) real pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of columns to be operated on i.e the number of columns of the distributed submatrix sub( a ). m >= 0 p (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 p (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the global location of the bottom of the unreduced submatrix of a the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer array into a local replicated array or vise versa. notice that the entire submatrix that is copied gets placed on one node o can receive, or just one row or column of nodes. the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer q's global row index, which points to the beginning of the submatrix which is to be operated on jq (global input) integer q's global row/col index, which points to the beginning of the submatrix which is to be operated on q (local output) real array, the total number of columns over which the distributed submatrix is distributed indx (workspace) integer array, dimension (n) the total number of columns over which the distributed submatrix is distributed info (output) integer z's global row index, which points to the beginning of the submatrix which is to be operated on jz (global input) integer ihi to ilo in steps of our schur block size (<=2*iblk). each iteration of the loop works with the active submatrix in row converged. either l = ilo or the global a(l,l-1) is negligible the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ) a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). when m = 0, pslang the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (input/output) real pointer into the local the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the global location of the bottom of the unreduced submatrix of a the number of columns to be operated on i.e the number of columns of the distributed submatrix sub( q ). n >= 0 d (global input/output) real array, dimmension (n) the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 a (local input) real pointer into the local memory the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nb (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bw (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bw (global input) integer the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 a (local input) real pointer into the local memory to an the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) real pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) real pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) real pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer ix (global input) pointer to integer the global row index of the submatrix of the distribute the splitting points, at which t breaks up into submatrices. the first submatrix consists of rows/columns 1 to isplit(1) etc., and the nsplit-th consists of rows/columns q's global row index, which points to the beginning of the submatrix which is to be operated on jq (global input) integer iblock (global input) integer array, dimension (n) the submatrix indices associated with the correspondin first submatrix from the top, 2 for those belonging to a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/workspace) block cyclic real array, a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) real pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) real pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) real pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) real pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) real pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) real pointer into the the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer ix (global input) pointer to integer the global row index of the submatrix of the distribute the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bwl (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 ilo (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 ilo (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex*16 pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of columns to be operated on i.e the number of columns of the distributed submatrix sub( a ). m >= 0 p (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 p (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex*16 pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex*16 pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex*16 pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex*16 pointer into the the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the global location of the bottom of the unreduced submatrix of a the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer array into a local replicated array or vise versa. notice that the entire submatrix that is copied gets placed on one node o can receive, or just one row or column of nodes. the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer z's global row index, which points to the beginning of the submatrix which is to be operated on jz (global input) integer ihi to ilo in steps of our schur block size (<=2*iblk). each iteration of the loop works with the active submatrix in row converged. either l = ilo or the global a(l,l-1) is negligible the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ) a's global row index, which points to the beginning of the submatrix which is to be operated on ja (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). when m = 0, pzlang the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (input/output) complex*16 pointer into the local the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the global location of the bottom of the unreduced submatrix of a the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 a (local input) complex*16 pointer into the local memory the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nb (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bw (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 bw (global input) integer the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 a (local input) complex*16 pointer into the local memory to an the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(ia:ia+n-1,ja:ja+n-1) the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex*16 pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex*16 pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex*16 pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer the number of rows and columns to be operated on, i.e. the order of the distributed submatrix a(1:n, ja:ja+n-1). n >= 0 nrhs (global input) integer iblock (global input) integer array, dimension (n) the submatrix indices associated with the correspondin first submatrix from the top, 2 for those belonging to the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex*16 pointer into the the number of rows and columns to be operated on, i.e. the order of the distributed submatrix sub( a ). n >= 0 a (local input/local output) complex*16 pointer into the the number of rows and columns to be operated on i.e the order of the distributed submatrix sub( a ). n >= 0 nrhs (global input) integer the number of rows to be operated on, i.e. the number of rows of the distributed submatrix sub( a ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix q. m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer the number of rows to be operated on i.e the number of rows of the distributed submatrix sub( c ). m >= 0 n (global input) integer scale submatrix in rows and columns l to len ihi to ilo in steps of 1 or 2. each iteration of the loop works with the active submatrix in rows and columns l to i h(l,l-1) is negligible so that the matrix splits. |
| subprograms subprograms where wpclange, wpclared1d, wpclared2d, wpcgebrd are the workspaces required respectively for the subprograms standard notation where wpdlange, wpdlared1d, wpdlared2d, wpdgebrd are the workspaces required respectively for the subprograms standard notation where wpslange, wpslared1d, wpslared2d, wpsgebrd are the workspaces required respectively for the subprograms standard notation where wpzlange, wpzlared1d, wpzlared2d, wpzgebrd are the workspaces required respectively for the subprograms standard notation |
| subroutine subroutine and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace tool function numroc; nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lrwork = -1, then lrwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo info (global output) integer myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo further details mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo ===================================================================== myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo alignment requirements myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo alignment requirements myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo further details and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. the scalar a which is used to divide each component of sub( x ). sa must be >= 0, or the subroutine will divide b myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace tool function numroc; nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace and overflow, and returns the square root of each of these values if the log of large is sufficiently large. this subroutine is intende and redefine the underflow and overflow limits to be the square roots myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo further details this is a scalapack internal subroutine and arguments are no mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo ===================================================================== myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo alignment requirements myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo alignment requirements myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo further details myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. the scalar a which is used to divide each component of sub( x ). sa must be >= 0, or the subroutine will divide b myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo for large n, no extra workspace is needed, however the myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo for large n, no extra workspace is needed, however the myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo info (global output) integer myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace 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. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace tool function numroc; nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace and overflow, and returns the square root of each of these values if the log of large is sufficiently large. this subroutine is intende and redefine the underflow and overflow limits to be the square roots myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo further details this is a scalapack internal subroutine and arguments are no mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo ===================================================================== myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo alignment requirements myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo alignment requirements myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo further details myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. the scalar a which is used to divide each component of sub( x ). sa must be >= 0, or the subroutine will divide b myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo for large n, no extra workspace is needed, however the myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo for large n, no extra workspace is needed, however the myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo info (global output) integer myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. the scalar a which is used to divide each component of sub( x ). sa must be >= 0, or the subroutine will divide b and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace tool function numroc; nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lrwork = -1, then lrwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo info (global output) integer myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo further details mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo ===================================================================== myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo alignment requirements myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo alignment requirements myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo further details and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. and as noted before, the *same* blacs context must be used in all descriptors in a single scalapack subroutine call let a be a generic term for any 1d block cyclicly distributed array. myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace myrow, mycol, nprow and npcol can be determined by calling the subroutine blacs_gridinfo if lwork = -1, then lwork is global input and a workspace |
| Subroutines Subroutines .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. executable statements .. .. .. external Subroutines . .. executable statements .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. executable statements .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. executable statements .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. executable statements .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. executable statements .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. external functions .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. executable statements .. .. .. external Subroutines . .. executable statements .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. intrinsic functions .. .. .. external Subroutines . .. intrinsic functions .. |
| subsequent subsequent each subsequent iteration determines a reflection g t chases the bulge one step toward the bottom of the active see how consecutive small subdiagonal elements are modified by subsequent shifts in an effort to maximize the number of bulge clamsh should only be called when there are multiple shifts/bulges see how consecutive small subdiagonal elements are modified by subsequent shifts in an effort to maximize the number of bulge dlamsh should only be called when there are multiple shifts/bulges copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent copy last diagonal block into af storage for subsequent see how consecutive small subdiagonal elements are modified by subsequent shifts in an effort to maximize the number of bulge slamsh should only be called when there are multiple shifts/bulges each subsequent iteration determines a reflection g t chases the bulge one step toward the bottom of the active see how consecutive small subdiagonal elements are modified by subsequent shifts in an effort to maximize the number of bulge zlamsh should only be called when there are multiple shifts/bulges |
| subsets subsets the computation of v, which could be performed in any processor column (or other procesor subsets), is performed in th can be updated prior to spreading v across. the computation of v, which could be performed in any processor column (or other procesor subsets), is performed in th can be updated prior to spreading v across. the computation of v, which could be performed in any processor column (or other procesor subsets), is performed in th can be updated prior to spreading v across. the computation of v, which could be performed in any processor column (or other procesor subsets), is performed in th can be updated prior to spreading v across. |
| substitution substitution the algorithm used in this program is basically backward (forward) substitution. it is the hope that scaling would be used to make th been implemented in pclattrs which is called by this routine to solve the algorithm used in this program is basically backward (forward) substitution. it is the hope that scaling would be used to make th been implemented in pzlattrs which is called by this routine to solve |
| subtle subtle details: the distinction between lii and ltli (and between liip1 and ltlip1) is subtle. within the current processo on some processors, a( lii, lij ) points to an element details: the distinction between lii and ltli (and between liip1 and ltlip1) is subtle. within the current processo on some processors, a( lii, lij ) points to an element details: the distinction between lii and ltli (and between liip1 and ltlip1) is subtle. within the current processo on some processors, a( lii, lij ) points to an element details: the distinction between lii and ltli (and between liip1 and ltlip1) is subtle. within the current processo on some processors, a( lii, lij ) points to an element |
| subtract subtract arithmetic. it will work on machines with a guard digit in add/subtract, or on those binary machines without guard digit it could conceivably fail on hexadecimal or decimal machines arithmetic. it will work on machines with a guard digit in add/subtract, or on those binary machines without guard digit it could conceivably fail on hexadecimal or decimal machines arithmetic. it will work on machines with a guard digit in add/subtract, or on those binary machines without guard digit it could conceivably fail on hexadecimal or decimal machines arithmetic. it will work on machines with a guard digit in add/subtract, or on those binary machines without guard digit it could conceivably fail on hexadecimal or decimal machines |
| successful successful info (output) integer = 0: successful exi > 0: if info = +i, u(i,i) is exactly zero. the factorization info (output) integer = 0: successful exi > 0: if info = i, u(i,i) is exactly zero. the factorization info (output) integer = 0: successful exi info (output) integer = 0: successful exi info (output) integer = 0: successful exi > 0: if info = +i, u(i,i) is exactly zero. the factorization info (output) integer = 0: successful exi > 0: if info = i, u(i,i) is exactly zero. the factorization info (output) integer = 0: successful exi matrix s was not originally in schur form. 0 indicates successful completion implemented by: g. henry, november 17, 1996 info (output) integer = 0: successful exi info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (output) integer = 0: successful exi info (global output) integer = 0: successful exi > 0: if info = i, and i is info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi > 0: if info = i, and i is info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (output) integer = 0: successful exi info (global output) integer = 0: successful exi > 0: if info = i, and i is info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (output) integer = 0: successful exit > 0: the algorithm failed to compute the ith eigenvalue. info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi > 0: if info = i, and i is info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0 : successful exi > 0 : some or all of the eigenvalues failed to converge or info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (output) integer = 0: successful exi info (global output) integer = 0: successful exi > 0: if info = i, and i is info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (output) integer = 0: successful exit > 0: the algorithm failed to compute the ith eigenvalue. info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi > 0: if info = i, and i is info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0 : successful exi > 0 : some or all of the eigenvalues failed to converge or info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (output) integer = 0: successful exi info (global output) integer = 0: successful exi > 0: if info = i, and i is info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi > 0: if info = i, and i is info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (local output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (global output) integer = 0: successful exi an illegal value, then info = -(i*100+j), if the i-th info (output) integer = 0: successful exi > 0: if info = +i, u(i,i) is exactly zero. the factorization info (output) integer = 0: successful exi > 0: if info = i, u(i,i) is exactly zero. the factorization info (output) integer = 0: successful exi matrix s was not originally in schur form. 0 indicates successful completion implemented by: g. henry, november 17, 1996 info (output) integer = 0: successful exi info (output) integer = 0: successful exi > 0: if info = +i, u(i,i) is exactly zero. the factorization info (output) integer = 0: successful exi > 0: if info = i, u(i,i) is exactly zero. the factorization info (output) integer = 0: successful exi info (output) integer = 0: successful exi |
| Such Such where l or u is the cholesky factor of a hermitian positive definite tridiagonal matrix a Such tha where l is the cholesky factor of a hermitian positive definite tridiagonal matrix a Such tha let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". pclarfg generates a complex elementary reflector h of order n, Such let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". pclassq returns the values scl and smsq Such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". the log of large is sufficiently large. this subroutine is intended to identify machines with a large exponent range, Such as the crays of the values computed by pdlamch. this subroutine is needed because let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". when there are multiple eigenvalues or if there is a zero in the z vector. for each Such occurence the dimension of th performed by the routine pdlaed2. eigenvalues are close together or if there is a tiny entry in the z vector. for each Such occurrence the order of the related secula let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". eps = relative machine precision sfmin = safe minimum, Such that 1/sfmin does not overflo prec = eps*base let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". pdlarfg generates a real elementary reflector h of order n, Such let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". pdlassq returns the values scl and smsq Such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". the log of large is sufficiently large. this subroutine is intended to identify machines with a large exponent range, Such as the crays of the values computed by pslamch. this subroutine is needed because let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". when there are multiple eigenvalues or if there is a zero in the z vector. for each Such occurence the dimension of th performed by the routine pslaed2. eigenvalues are close together or if there is a tiny entry in the z vector. for each Such occurrence the order of the related secula let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". eps = relative machine precision sfmin = safe minimum, Such that 1/sfmin does not overflo prec = eps*base let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". pslarfg generates a real elementary reflector h of order n, Such let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". pslassq returns the values scl and smsq Such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". pzlarfg generates a complex elementary reflector h of order n, Such let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". pzlassq returns the values scl and smsq Such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". let a be a generic term for any 2d block cyclicly distributed array. Such a global array has an associated description vector desca "of the global array". where l is the cholesky factor of a hermitian positive definite tridiagonal matrix a Such tha where l or u is the cholesky factor of a hermitian positive definite tridiagonal matrix a Such tha |
| sufficient sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pcheevx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pchegvx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pdsyevx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pdsygvx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pssyevx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pssygvx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pzheevx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pzhegvx is not able to detect thi requested, the user must supply both sufficient |
| sufficiently sufficiently and overflow, and returns the square root of each of these values if the log of large is sufficiently large. this subroutine is intende and redefine the underflow and overflow limits to be the square roots is narrower than abstol, or than reltol times the larger (in magnitude) endpoint, then it is considered to be sufficiently this must be at least zero. is narrower than abstol, or than reltol times the larger (in magnitude) endpoint, then it is considered to be sufficiently note : this must be at least zero. and overflow, and returns the square root of each of these values if the log of large is sufficiently large. this subroutine is intende and redefine the underflow and overflow limits to be the square roots is narrower than abstol, or than reltol times the larger (in magnitude) endpoint, then it is considered to be sufficiently this must be at least zero. is narrower than abstol, or than reltol times the larger (in magnitude) endpoint, then it is considered to be sufficiently note : this must be at least zero. |
| sum sum the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, or its conjugate-transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where norm1 denotes the one norm of a matrix (maximum column sum) normf denotes the frobenius norm of a matrix (square root of sum of if the matrix is hermitian, we address only a triangular portion of the matrix. a sum of row (column) i of the complete matri triangular matrix, stopping/starting at the diagonal, which is find sum of global matrix columns and store on row 0 o if the matrix is symmetric, we address only a triangular portion of the matrix. a sum of row (column) i of the complete matri triangular matrix, stopping/starting at the diagonal, which is find sum of global matrix columns and store on row 0 o ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). compute x(j) = b(j) - sum a(k,j)*x(k) the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, or its transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where norm1 denotes the one norm of a matrix (maximum column sum) normf denotes the frobenius norm of a matrix (square root of sum of find sum of global matrix columns and store on row 0 o if the matrix is symmetric, we address only a triangular portion of the matrix. a sum of row (column) i of the complete matri triangular matrix, stopping/starting at the diagonal, which is find sum of global matrix columns and store on row 0 o ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ). the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its pdzsum1 returns the sum of absolute values of a comple pscsum1 returns the sum of absolute values of a comple the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, or its transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where norm1 denotes the one norm of a matrix (maximum column sum) normf denotes the frobenius norm of a matrix (square root of sum of find sum of global matrix columns and store on row 0 o if the matrix is symmetric, we address only a triangular portion of the matrix. a sum of row (column) i of the complete matri triangular matrix, stopping/starting at the diagonal, which is find sum of global matrix columns and store on row 0 o ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ). the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, or its conjugate-transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where norm1 denotes the one norm of a matrix (maximum column sum) normf denotes the frobenius norm of a matrix (square root of sum of if the matrix is hermitian, we address only a triangular portion of the matrix. a sum of row (column) i of the complete matri triangular matrix, stopping/starting at the diagonal, which is find sum of global matrix columns and store on row 0 o if the matrix is symmetric, we address only a triangular portion of the matrix. a sum of row (column) i of the complete matri triangular matrix, stopping/starting at the diagonal, which is find sum of global matrix columns and store on row 0 o ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). compute x(j) = b(j) - sum a(k,j)*x(k) the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, |
| Summary Summary Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 Summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 |
| sums sums the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below ar to as colsums. infinity-norm = 1-norm = rowsums+colsums. the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below ar to as colsums. infinity-norm = 1-norm = rowsums+colsums. the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below ar to as colsums. infinity-norm = 1-norm = rowsums+colsums. the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below ar to as colsums. infinity-norm = 1-norm = rowsums+colsums. the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below ar to as colsums. infinity-norm = 1-norm = rowsums+colsums. the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below ar to as colsums. infinity-norm = 1-norm = rowsums+colsums. |
| sumsq sumsq ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ). ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ). ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). |
| superdiagonal superdiagonal kv is the number of superdiagonals in the factor matrices and u is upper triangular with nonzeros in only the main diagonal and first superdiagonal arguments du (input) complex array, dimension (n-1) the (n-1) elements of the first superdiagonal of u b (input/output) complex array, dimension (ldb,nrhs) uplo (input) character*1 specifies whether the superdiagonal or the subdiagona factorization: look for small superdiagonal element kv is the number of superdiagonals in the factor matrices and u is upper triangular with nonzeros in only the main diagonal and first superdiagonal arguments du (input) complex array, dimension (n-1) the (n-1) elements of the first superdiagonal of u b (input/output) complex array, dimension (ldb,nrhs) look for small superdiagonal element general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) ar below the diagonal, with the array tauq, represent the general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) ar below the diagonal, with the array tauq, represent the triangular matrix l; if m <= n, the elements on and below the (n-m)-th superdiagonal contain the m by n lowe array tau, represent the unitary matrix q as a product of triangular matrix l; if m <= n, the elements on and below the (n-m)-th superdiagonal contain the m by n lowe array tau, represent the unitary matrix q as a product of triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, 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 superdiagonal
general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) ar below the diagonal, with the array tauq, represent the general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) ar below the diagonal, with the array tauq, represent the triangular matrix l; if m <= n, the elements on and below the (n-m)-th superdiagonal contain the m by n lowe array tau, represent the orthogonal matrix q as a product of triangular matrix l; if m <= n, the elements on and below the (n-m)-th superdiagonal contain the m by n lowe array tau, represent the orthogonal matrix q as a product of 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 superdiagonal
triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) ar below the diagonal, with the array tauq, represent the general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) ar below the diagonal, with the array tauq, represent the triangular matrix l; if m <= n, the elements on and below the (n-m)-th superdiagonal contain the m by n lowe array tau, represent the orthogonal matrix q as a product of triangular matrix l; if m <= n, the elements on and below the (n-m)-th superdiagonal contain the m by n lowe array tau, represent the orthogonal matrix q as a product of 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 superdiagonal
triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) ar below the diagonal, with the array tauq, represent the general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) ar below the diagonal, with the array tauq, represent the triangular matrix l; if m <= n, the elements on and below the (n-m)-th superdiagonal contain the m by n lowe array tau, represent the unitary matrix q as a product of triangular matrix l; if m <= n, the elements on and below the (n-m)-th superdiagonal contain the m by n lowe array tau, represent the unitary matrix q as a product of triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, 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 superdiagonal
kv is the number of superdiagonals in the factor matrices and u is upper triangular with nonzeros in only the main diagonal and first superdiagonal arguments du (input) complex array, dimension (n-1) the (n-1) elements of the first superdiagonal of u b (input/output) complex array, dimension (ldb,nrhs) kv is the number of superdiagonals in the factor matrices and u is upper triangular with nonzeros in only the main diagonal and first superdiagonal arguments du (input) complex array, dimension (n-1) the (n-1) elements of the first superdiagonal of u b (input/output) complex array, dimension (ldb,nrhs) uplo (input) character*1 specifies whether the superdiagonal or the subdiagona factorization: look for small superdiagonal element |
| superdiagonals superdiagonals ku (input) integer the number of superdiagonals within the band of a. ku >= 0 ab (input/output) complex array, dimension (ldab,n) kv is the number of superdiagonals in the factor ku (input) integer the number of superdiagonals within the band of a. ku >= 0 ab (input/output) double precision array, dimension (ldab,n) kv is the number of superdiagonals in the factor bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer bwu (global input) integer number of superdiagonals. 0 <= bwu <= n- nrhs (global input) integer ku (input) integer the number of superdiagonals within the band of a. ku >= 0 ab (input/output) real array, dimension (ldab,n) kv is the number of superdiagonals in the factor ku (input) integer the number of superdiagonals within the band of a. ku >= 0 ab (input/output) complex*16 array, dimension (ldab,n) kv is the number of superdiagonals in the factor |
| supplied supplied specifies whether or not the factored form of the matrix a(ia:ia+n-1,ja:ja+n-1) is supplied on entry, and if not equilibrated before it is factored. the computed eigenvectors may not be orthogonal if the minimal workspace is supplied and orfac is too small of potentially poor performance) you should add the computed eigenvectors may not be orthogonal if the minimal workspace is supplied and orfac is too small of potentially poor performance) you should add scale and sumsq must be supplied in scale and sumsq respectively 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. specifies whether or not the factored form of the matrix a is supplied on entry, and if not, whether the matrix a should b = 'f': on entry, af contains the factored form of a. and backtransform them using the input matrices supplied in vr and/or vl specified by the logical array select. specifies whether or not the factored form of the matrix a(ia:ia+n-1,ja:ja+n-1) is supplied on entry, and if not equilibrated before it is factored. scale and sumsq must be supplied in scale and sumsq respectively 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. specifies whether or not the factored form of the matrix a is supplied on entry, and if not, whether the matrix a should b = 'f': on entry, af contains the factored form of a. the computed eigenvectors may not be orthogonal if the minimal workspace is supplied and orfac is too small of potentially poor performance) you should add the computed eigenvectors may not be orthogonal if the minimal workspace is supplied and orfac is too small of potentially poor performance) you should add specifies whether or not the factored form of the matrix a(ia:ia+n-1,ja:ja+n-1) is supplied on entry, and if not equilibrated before it is factored. scale and sumsq must be supplied in scale and sumsq respectively 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. specifies whether or not the factored form of the matrix a is supplied on entry, and if not, whether the matrix a should b = 'f': on entry, af contains the factored form of a. the computed eigenvectors may not be orthogonal if the minimal workspace is supplied and orfac is too small of potentially poor performance) you should add the computed eigenvectors may not be orthogonal if the minimal workspace is supplied and orfac is too small of potentially poor performance) you should add specifies whether or not the factored form of the matrix a(ia:ia+n-1,ja:ja+n-1) is supplied on entry, and if not equilibrated before it is factored. the computed eigenvectors may not be orthogonal if the minimal workspace is supplied and orfac is too small of potentially poor performance) you should add the computed eigenvectors may not be orthogonal if the minimal workspace is supplied and orfac is too small of potentially poor performance) you should add scale and sumsq must be supplied in scale and sumsq respectively 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. specifies whether or not the factored form of the matrix a is supplied on entry, and if not, whether the matrix a should b = 'f': on entry, af contains the factored form of a. and backtransform them using the input matrices supplied in vr and/or vl specified by the logical array select. |
| supplies supplies if jobz .ne. 'v', nz is not referenced. if jobz .eq. 'v', nz = m unless the user supplies 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 supplies 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 supplies 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 supplies 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 supplies 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 supplies 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 supplies 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 supplies before beginning computation. to get all the eigenvectors |
| supply supply before beginning computation. to get all the eigenvectors requested, the user must supply both sufficien and sufficient workspace to compute them. (see lwork below.) before beginning computation. to get all the eigenvectors requested, the user must supply both sufficien and sufficient workspace to compute them. (see lwork below.) before beginning computation. to get all the eigenvectors requested, the user must supply both sufficien and sufficient workspace to compute them. (see lwork below.) before beginning computation. to get all the eigenvectors requested, the user must supply both sufficien and sufficient workspace to compute them. (see lwork below.) before beginning computation. to get all the eigenvectors requested, the user must supply both sufficien and sufficient workspace to compute them. (see lwork below.) before beginning computation. to get all the eigenvectors requested, the user must supply both sufficien and sufficient workspace to compute them. (see lwork below.) before beginning computation. to get all the eigenvectors requested, the user must supply both sufficien and sufficient workspace to compute them. (see lwork below.) before beginning computation. to get all the eigenvectors requested, the user must supply both sufficien and sufficient workspace to compute them. (see lwork below.) |
| Support Support since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the Support for uplo='u' is limited to calling the old, slow, pchetr since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the all of b or a submatrix of b). important note: the current version of this code Support since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the in addition, this routine performs a global minimization and maximi- zation on these values, to Support heterogeneous computing networks arguments since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the all of b or a submatrix of b). important note: the current version of this code Support Support for uplo='u' is limited to calling the old, slow, pdsytr since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the in addition, this routine performs a global minimization and maximi- zation on these values, to Support heterogeneous computing networks arguments since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the all of b or a submatrix of b). important note: the current version of this code Support Support for uplo='u' is limited to calling the old, slow, pssytr since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the Support for uplo='u' is limited to calling the old, slow, pzhetr since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack Supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the all of b or a submatrix of b). important note: the current version of this code Support |
| supported supported the process grid must be square ( i.e. nprow = npcol ) and only lower triangular storage is supported local variables the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x currently, only storev = 'r' and direct = 'b' are supported notes currently, only storev = 'r' and direct = 'b' are supported notes the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x currently, only storev = 'r' and direct = 'b' are supported notes currently, only storev = 'r' and direct = 'b' are supported notes the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== the process grid must be square ( i.e. nprow = npcol ) and only lower triangular storage is supported local variables the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x currently, only storev = 'r' and direct = 'b' are supported notes currently, only storev = 'r' and direct = 'b' are supported notes the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== the process grid must be square ( i.e. nprow = npcol ) and only lower triangular storage is supported local variables the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== the process grid must be square ( i.e. nprow = npcol ) and only lower triangular storage is supported local variables the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x currently, only storev = 'r' and direct = 'b' are supported notes currently, only storev = 'r' and direct = 'b' are supported notes the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x |
| supports supports since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the all of b or a submatrix of b). important note: the current version of this code supports since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the all of b or a submatrix of b). important note: the current version of this code supports since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the all of b or a submatrix of b). important note: the current version of this code supports since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the since scalapack supports two-dimensional arrays as the fundamenta first dimension of the array (as if the grid were p-by-1) or the all of b or a submatrix of b). important note: the current version of this code supports |
| sure sure $ ( two*( c*oldrp-b )+safmin ) make sure that we are making progres skip the current step: the subdiagonal info is just noise. check to make sure no processors have found error check to make sure no processors have found error make sure it's divisible by lcm (we want even workloads! i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. check to make sure no processors have found error check to make sure no processors have found error check to make sure no processors have found error check to make sure no processors have found error make sure it's divisible by lcm (we want even workloads! i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. check to make sure no processors have found error check to make sure no processors have found error check to make sure no processors have found error check to make sure no processors have found error make sure it's divisible by lcm (we want even workloads! i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. check to make sure no processors have found error check to make sure no processors have found error check to make sure no processors have found error check to make sure no processors have found error make sure it's divisible by lcm (we want even workloads! i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. check to make sure no processors have found error check to make sure no processors have found error $ ( two*( c*oldrp-b )+safmin ) make sure that we are making progres skip the current step: the subdiagonal info is just noise. |
| suspect suspect i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore |
| SVD SVD pcgeSVD computes the singular value decomposition (svd) of a singular vectors. the svd is written as pdgeSVD computes the singular value decomposition (svd) of a singular vectors. the svd is written as psgeSVD computes the singular value decomposition (svd) of a singular vectors. the svd is written as pzgeSVD computes the singular value decomposition (svd) of a singular vectors. the svd is written as |
| swapped swapped element (l,ln+1) is swapped with element (j,ln+1) et the complicated formulas are to cope with the banded by pcgetrf. ipiv(i) -> the global row local row i was swapped with. this array is tied to the distribute this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with pcgetrf; ipiv(i) -> the global row local row i was swapped with. this array must be aligned wit this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with keeps track of the pivoting information. ipiv(i) is the global row index the local row i was swapped with. thi this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with this array contains the pivoting information. ipiv(i) is the global row (column), local row (column) i was swapped with or 'c' and pivroc='r' or 'r', the last piece of this array of the pivoting information. ipiv(i) is the global row (column), local row (column) i was swapped with. the last piece of th tied to the distributed matrix a. element (l,ln+1) is swapped with element (j,ln+1) et the complicated formulas are to cope with the banded by pdgetrf. ipiv(i) -> the global row local row i was swapped with. this array is tied to the distribute this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with pdgetrf; ipiv(i) -> the global row local row i was swapped with. this array must be aligned wit this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with keeps track of the pivoting information. ipiv(i) is the global row index the local row i was swapped with. thi this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with this array contains the pivoting information. ipiv(i) is the global row (column), local row (column) i was swapped with or 'c' and pivroc='r' or 'r', the last piece of this array of the pivoting information. ipiv(i) is the global row (column), local row (column) i was swapped with. the last piece of th tied to the distributed matrix a. element (l,ln+1) is swapped with element (j,ln+1) et the complicated formulas are to cope with the banded by psgetrf. ipiv(i) -> the global row local row i was swapped with. this array is tied to the distribute this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with psgetrf; ipiv(i) -> the global row local row i was swapped with. this array must be aligned wit this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with keeps track of the pivoting information. ipiv(i) is the global row index the local row i was swapped with. thi this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with this array contains the pivoting information. ipiv(i) is the global row (column), local row (column) i was swapped with or 'c' and pivroc='r' or 'r', the last piece of this array of the pivoting information. ipiv(i) is the global row (column), local row (column) i was swapped with. the last piece of th tied to the distributed matrix a. element (l,ln+1) is swapped with element (j,ln+1) et the complicated formulas are to cope with the banded by pzgetrf. ipiv(i) -> the global row local row i was swapped with. this array is tied to the distribute this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with pzgetrf; ipiv(i) -> the global row local row i was swapped with. this array must be aligned wit this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with keeps track of the pivoting information. ipiv(i) is the global row index the local row i was swapped with. thi this array contains the pivoting information. ipiv(i) -> the global row local row i was swapped with this array contains the pivoting information. ipiv(i) is the global row (column), local row (column) i was swapped with or 'c' and pivroc='r' or 'r', the last piece of this array of the pivoting information. ipiv(i) is the global row (column), local row (column) i was swapped with. the last piece of th tied to the distributed matrix a. |
| switch switch to a system which does not have ieee 754 arithmetic, modify the appropriate slmake.inc file to include the compiler switch to a system which does not have ieee 754 arithmetic, modify the appropriate slmake.inc file to include the compiler switch to a system which does not have ieee 754 arithmetic, modify the appropriate slmake.inc file to include the compiler switch to a system which does not have ieee 754 arithmetic, modify the appropriate slmake.inc file to include the compiler switch |
| symmetric symmetric pcheev computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequenc specifies whether the upper or lower triangular part of the symmetric matrix a is stored = 'l': lower triangular if the matrix is symmetric, we address only a triangular portio can be obtained by adding along row i and column i of the the pclaqsy equilibrates a symmetric distributed matri vectors sr and sc. where a(1:n, ja:ja+n-1) is an n-by-n complex banded symmetric positive definite distribute a(1:n, ja:ja+n-1) is an n-by-n complex banded symmetric positive definite distribute depending on the value of uplo, a stores either u or l in the equn on entry, this array contains the local pieces of the n-by-n symmetric distributed matrix sub( a ) to be factored sub( a ) contains the upper triangular part of the matrix, on entry, this array contains the local pieces of the n-by-n symmetric distributed matrix sub( a ) to be factored sub( a ) contains the upper triangular part of the matrix, where a(1:n, ja:ja+n-1) is an n-by-n complex tridiagonal symmetric positive definite distribute a(1:n, ja:ja+n-1) is an n-by-n complex tridiagonal symmetric positive definite distribute depending on the value of uplo, a stores either u or l in the equn pcstein computes the eigenvectors of a symmetric tridiagonal matri correspond to user specified eigenvalues. pcstein does not j = 1,...,minp. it uses and computes the function n(w), which is the count of eigenvalues of a symmetric tridiagonal matrix less tha pdlaed0 computes all eigenvalues and corresponding eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method pdlaed1 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix n (input) integer the dimension of the symmetric tridiagonal matrix. n >= 0 n1 (input) integer n (input) integer the dimension of the symmetric tridiagonal matrix. n >= 0 nb (global input) integer if the matrix is symmetric, we address only a triangular portio can be obtained by adding along row i and column i of the the pdlaqsy equilibrates a symmetric distributed matri vectors sr and sc. pdlatrd reduces nb rows and columns of a real symmetric distribute form by an orthogonal similarity transformation q' * sub( a ) * q, where a(1:n, ja:ja+n-1) is an n-by-n real banded symmetric positive definite distribute a(1:n, ja:ja+n-1) is an n-by-n real banded symmetric positive definite distribute depending on the value of uplo, a stores either u or l in the equn pdpocon estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite distributed matri pdpotrf. pdpoequ computes row and column scalings intended to equilibrate a distributed symmetric positive definite matri (with respect to the two-norm). sr and sc contain the scale pdporfs improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definit solutions. where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is an n-by-n symmetric distributed positive definite matrix and x and sub( b matrices. ( lld_a, locc(ja+n-1) ). on entry, the symmetric matrix a, except if fact = 'f' an diag(sr)*a*diag(sc). if uplo = 'u', the leading pdpotf2 computes the cholesky factorization of a real symmetric pdpotrf computes the cholesky factorization of an n-by-n real symmetric positive definite distributed matrix sub( a ) denotin pdpotri computes the inverse of a real symmetric positive definit cholesky factorization sub( a ) = u**t*u or l*l**t computed by 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). where a(1:n, ja:ja+n-1) is an n-by-n real tridiagonal symmetric positive definite distribute a(1:n, ja:ja+n-1) is an n-by-n real tridiagonal symmetric positive definite distribute pdstebz computes the eigenvalues of a symmetric tridiagonal matrix i the interval [vl, vu], or the eigenvalues indexed il through iu. a 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 matri correspond to user specified eigenvalues. pdstein does not pdsyev computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequenc pdsyevd computes all the eigenvalues and eigenvectors of a real symmetric matrix a by calling the recommended sequenc pdsyevx computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequenc specifying a range of values or a range of indices for the desired pdsygs2 reduces a real symmetric-definite generalized eigenproble pdsygst reduces a real symmetric-definite generalized eigenproble sy, and sub( b ) denoting b( ib:ib+n-1, jb:jb+n-1 ) is assumed to be symmetric positive definite notes pdsyntrd reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pdsytd2 reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pdsytrd reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pjlaenv is called from the scalapack symmetric and hermitia problem-dependent parameters for the local environment. see ispec j = 1,...,minp. it uses and computes the function n(w), which is the count of eigenvalues of a symmetric tridiagonal matrix less tha pslaed0 computes all eigenvalues and corresponding eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method pslaed1 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix n (input) integer the dimension of the symmetric tridiagonal matrix. n >= 0 n1 (input) integer n (input) integer the dimension of the symmetric tridiagonal matrix. n >= 0 nb (global input) integer if the matrix is symmetric, we address only a triangular portio can be obtained by adding along row i and column i of the the pslaqsy equilibrates a symmetric distributed matri vectors sr and sc. pslatrd reduces nb rows and columns of a real symmetric distribute form by an orthogonal similarity transformation q' * sub( a ) * q, where a(1:n, ja:ja+n-1) is an n-by-n real banded symmetric positive definite distribute a(1:n, ja:ja+n-1) is an n-by-n real banded symmetric positive definite distribute depending on the value of uplo, a stores either u or l in the equn pspocon estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite distributed matri pspotrf. pspoequ computes row and column scalings intended to equilibrate a distributed symmetric positive definite matri (with respect to the two-norm). sr and sc contain the scale psporfs improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definit solutions. where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is an n-by-n symmetric distributed positive definite matrix and x and sub( b matrices. ( lld_a, locc(ja+n-1) ). on entry, the symmetric matrix a, except if fact = 'f' an diag(sr)*a*diag(sc). if uplo = 'u', the leading pspotf2 computes the cholesky factorization of a real symmetric pspotrf computes the cholesky factorization of an n-by-n real symmetric positive definite distributed matrix sub( a ) denotin pspotri computes the inverse of a real symmetric positive definit cholesky factorization sub( a ) = u**t*u or l*l**t computed by 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). where a(1:n, ja:ja+n-1) is an n-by-n real tridiagonal symmetric positive definite distribute a(1:n, ja:ja+n-1) is an n-by-n real tridiagonal symmetric positive definite distribute psstebz computes the eigenvalues of a symmetric tridiagonal matrix i the interval [vl, vu], or the eigenvalues indexed il through iu. a 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 matri correspond to user specified eigenvalues. psstein does not pssyev computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequenc pssyevd computes all the eigenvalues and eigenvectors of a real symmetric matrix a by calling the recommended sequenc pssyevx computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequenc specifying a range of values or a range of indices for the desired pssygs2 reduces a real symmetric-definite generalized eigenproble pssygst reduces a real symmetric-definite generalized eigenproble sy, and sub( b ) denoting b( ib:ib+n-1, jb:jb+n-1 ) is assumed to be symmetric positive definite notes pssyntrd reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pssytd2 reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pssytrd reduces a real symmetric matrix sub( a ) to symmetri q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pzheev computes selected eigenvalues and, optionally, eigenvectors of a real symmetric matrix a by calling the recommended sequenc specifies whether the upper or lower triangular part of the symmetric matrix a is stored = 'l': lower triangular if the matrix is symmetric, we address only a triangular portio can be obtained by adding along row i and column i of the the pzlaqsy equilibrates a symmetric distributed matri vectors sr and sc. where a(1:n, ja:ja+n-1) is an n-by-n complex banded symmetric positive definite distribute a(1:n, ja:ja+n-1) is an n-by-n complex banded symmetric positive definite distribute depending on the value of uplo, a stores either u or l in the equn on entry, this array contains the local pieces of the n-by-n symmetric distributed matrix sub( a ) to be factored sub( a ) contains the upper triangular part of the matrix, on entry, this array contains the local pieces of the n-by-n symmetric distributed matrix sub( a ) to be factored sub( a ) contains the upper triangular part of the matrix, where a(1:n, ja:ja+n-1) is an n-by-n complex tridiagonal symmetric positive definite distribute a(1:n, ja:ja+n-1) is an n-by-n complex tridiagonal symmetric positive definite distribute depending on the value of uplo, a stores either u or l in the equn pzstein computes the eigenvectors of a symmetric tridiagonal matri correspond to user specified eigenvalues. pzstein does not |
| System System singular, and division by zero will occur if it is used to solve a System of equations further details singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== cdttrsv solves one of the Systems of equation u * x = b, u**t * x = b, or u**h * x = b, cpttrsv solves one of the triangular System u * x = b, or u**h * x = b, singular, and division by zero will occur if it is used to solve a System of equations further details singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== ddttrsv solves one of the Systems of equation u * x = b, u**t * x = b, or u**h * x = b, dpttrsv solves one of the triangular System where l is the cholesky factor of a hermitian positive solve the System lu = pb pcdbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{bu'}_i} = {b_i
pcdbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System pcdtsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) compute contribution to diagonal block(s) of reduced System pcdttrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System pcgbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) ******************************************************************* phase 2: formation and factorization of reduced System pcgbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pcgels solves overdetermined or underdetermined complex linear Systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) sub( a ). it is assumed that sub( a ) has full rank. pcgerfs improves the computed solution to a System of linea the solutions. pcgesv computes the solution to a complex System of linear equation sub( a ) * x = sub( b ), pcgesvx uses the lu factorization to compute the solution to a complex System of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), is exactly singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== is exactly singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted inva by solving the System inva*l = inv(u) for inva notes pcgetrs solves a System of distributed linear equation op( sub( a ) ) * x = sub( b ) in its present form, pcheev assumes a homogeneous System and make different processes. because of this, it is possible that a pcheevx assumes ieee 754 standard compliant arithmetic. to port to a System which does not have ieee 754 arithmetic, modif -dno_ieee. this switch only affects the compilation of pslaiect.c. pcpbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{b'}_i}^c = {b_i}^
pcpbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System pcporfs improves the computed solution to a System of linea and provides error bounds and backward error estimates for the pcposv computes the solution to a complex System of linear equation sub( a ) * x = sub( b ), pcposvx uses the cholesky factorization a = u**h*u or a = l*l**h to compute the solution to a complex System of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), pcpotrs solves a System of linear equation sub( a ) * x = sub( b ) pcptsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{b'}_i}^c = {b_i}^
pcpttrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System pctrrfs provides error bounds and backward error estimates for the solution to a System of linear equations with a triangula pctrtrs solves a triangular System of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ) or pddbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{bu'}_i} = {b_i
pddbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System pddtsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) compute contribution to diagonal block(s) of reduced System pddttrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System pdgbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) ******************************************************************* phase 2: formation and factorization of reduced System pdgbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pdgels solves overdetermined or underdetermined real linear Systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) assumed that sub( a ) has full rank. pdgerfs improves the computed solution to a System of linea the solutions. pdgesv computes the solution to a real System of linear equation sub( a ) * x = sub( b ), pdgesvx uses the lu factorization to compute the solution to a real System of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), is exactly singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== is exactly singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted inva by solving the System inva*l = inv(u) for inva notes pdgetrs solves a System of distributed linear equation op( sub( a ) ) * x = sub( b ) pdpbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{b'}_i}^t = {b_i}^
pdpbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System pdporfs improves the computed solution to a System of linea and provides error bounds and backward error estimates for the pdposv computes the solution to a real System of linear equation sub( a ) * x = sub( b ), pdposvx uses the cholesky factorization a = u**t*u or a = l*l**t to compute the solution to a real System of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), pdpotrs solves a System of linear equation sub( a ) * x = sub( b ) pdptsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{b'}_i}^t = {b_i}^
pdpttrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System in its present form, pdsyev assumes a homogeneous System and make the different processes. because of this, it is possible that a in its present form, pdsyevd assumes a homogeneous System and make the different processes. because of this, it is possible that a pdsyevx assumes ieee 754 standard compliant arithmetic. to port to a System which does not have ieee 754 arithmetic, modif -dno_ieee. this switch only affects the compilation of pdlaiect.c. pdtrrfs provides error bounds and backward error estimates for the solution to a System of linear equations with a triangula pdtrtrs solves a triangular System of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ), psdbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{bu'}_i} = {b_i
psdbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System psdtsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) compute contribution to diagonal block(s) of reduced System psdttrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System psgbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) ******************************************************************* phase 2: formation and factorization of reduced System psgbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) psgels solves overdetermined or underdetermined real linear Systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) assumed that sub( a ) has full rank. psgerfs improves the computed solution to a System of linea the solutions. psgesv computes the solution to a real System of linear equation sub( a ) * x = sub( b ), psgesvx uses the lu factorization to compute the solution to a real System of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), is exactly singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== is exactly singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted inva by solving the System inva*l = inv(u) for inva notes psgetrs solves a System of distributed linear equation op( sub( a ) ) * x = sub( b ) pspbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{b'}_i}^t = {b_i}^
pspbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System psporfs improves the computed solution to a System of linea and provides error bounds and backward error estimates for the psposv computes the solution to a real System of linear equation sub( a ) * x = sub( b ), psposvx uses the cholesky factorization a = u**t*u or a = l*l**t to compute the solution to a real System of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), pspotrs solves a System of linear equation sub( a ) * x = sub( b ) psptsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{b'}_i}^t = {b_i}^
pspttrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System in its present form, pssyev assumes a homogeneous System and make the different processes. because of this, it is possible that a in its present form, pssyevd assumes a homogeneous System and make the different processes. because of this, it is possible that a pssyevx assumes ieee 754 standard compliant arithmetic. to port to a System which does not have ieee 754 arithmetic, modif -dno_ieee. this switch only affects the compilation of pslaiect.c. pstrrfs provides error bounds and backward error estimates for the solution to a System of linear equations with a triangula pstrtrs solves a triangular System of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ), pzdbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{bu'}_i} = {b_i
pzdbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System pzdtsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) compute contribution to diagonal block(s) of reduced System pzdttrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System pzgbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) ******************************************************************* phase 2: formation and factorization of reduced System pzgbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) pzgels solves overdetermined or underdetermined complex linear Systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) sub( a ). it is assumed that sub( a ) has full rank. pzgerfs improves the computed solution to a System of linea the solutions. pzgesv computes the solution to a complex System of linear equation sub( a ) * x = sub( b ), pzgesvx uses the lu factorization to compute the solution to a complex System of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), is exactly singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== is exactly singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== computes the inverse of sub( a ) = a(ia:ia+n-1,ja:ja+n-1) denoted inva by solving the System inva*l = inv(u) for inva notes pzgetrs solves a System of distributed linear equation op( sub( a ) ) * x = sub( b ) in its present form, pzheev assumes a homogeneous System and make different processes. because of this, it is possible that a pzheevx assumes ieee 754 standard compliant arithmetic. to port to a System which does not have ieee 754 arithmetic, modif -dno_ieee. this switch only affects the compilation of pdlaiect.c. pzpbsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{b'}_i}^c = {b_i}^
pzpbtrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System pzporfs improves the computed solution to a System of linea and provides error bounds and backward error estimates for the pzposv computes the solution to a complex System of linear equation sub( a ) * x = sub( b ), pzposvx uses the cholesky factorization a = u**h*u or a = l*l**h to compute the solution to a complex System of linear equation a(ia:ia+n-1,ja:ja+n-1) * x = b(ib:ib+n-1,jb:jb+nrhs-1), pzpotrs solves a System of linear equation sub( a ) * x = sub( b ) pzptsv solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs)
perform the triangular System solve {l_i}{{b'}_i}^c = {b_i}^
pzpttrs solves a System of linear equation a(1:n, ja:ja+n-1) * x = b(ib:ib+n-1, 1:nrhs) *********************************************** formation and solution of reduced System pztrrfs provides error bounds and backward error estimates for the solution to a System of linear equations with a triangula pztrtrs solves a triangular System of the for sub( a ) * x = sub( b ) or sub( a )**t * x = sub( b ) or singular, and division by zero will occur if it is used to solve a System of equations further details singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== sdttrsv solves one of the Systems of equation u * x = b, u**t * x = b, or u**h * x = b, spttrsv solves one of the triangular System where l is the cholesky factor of a hermitian positive solve the System lu = pb singular, and division by zero will occur if it is used to solve a System of equations further details singular, and division by zero will occur if it is used to solve a System of equations ===================================================================== zdttrsv solves one of the Systems of equation u * x = b, u**t * x = b, or u**h * x = b, zpttrsv solves one of the triangular System u * x = b, or u**h * x = b, |
| systems systems cdttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, cpttrsv solves one of the triangular systems u * x = b, or u**h * x = b, ddttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, dpttrsv solves one of the triangular systems where l is the cholesky factor of a hermitian positive the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are pcgels solves overdetermined or underdetermined complex linear systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) sub( a ). it is assumed that sub( a ) has full rank. the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are been implemented in pclattrs which is called by this routine to solve the triangular systems. pclattrs just calls pctrsv each eigenvector is normalized so that the element of largest the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are pdgels solves overdetermined or underdetermined real linear systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) assumed that sub( a ) has full rank. the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are psgels solves overdetermined or underdetermined real linear systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) assumed that sub( a ) has full rank. the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are pzgels solves overdetermined or underdetermined complex linear systems involving an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) sub( a ). it is assumed that sub( a ) has full rank. the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are the best algorithm for solving banded and tridiagonal linear systems currently, only algorithms designed for the case n/p >> bw are been implemented in pzlattrs which is called by this routine to solve the triangular systems. pzlattrs just calls pztrsv each eigenvector is normalized so that the element of largest sdttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, spttrsv solves one of the triangular systems where l is the cholesky factor of a hermitian positive zdttrsv solves one of the systems of equation u * x = b, u**t * x = b, or u**h * x = b, zpttrsv solves one of the triangular systems u * x = b, or u**h * x = b, |