Back| W- |
| waits waits the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop the last processor does not participate in the solution of the reduced system and just waits to receive its solution determine number of steps in tree loop |
| Want Want 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. 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. Want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. minimal workspace is supplied and orfac is too small. if you Want to guarantee orthogonality (at the cos the following to lrwork: minimal workspace is supplied and orfac is too small. if you Want to guarantee orthogonality (at the cos the following to lrwork: for schur form, use 2x2 blocks if we don't Want the schur form, use bigger blocks now the active submatrix is in rows and columns l to i. if 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 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. 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. 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. 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. Want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. make sure it's divisible by lcm (we Want even workloads! 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 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. 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. minimal workspace is supplied and orfac is too small. if you Want to guarantee orthogonality (at the cos the following to lwork: minimal workspace is supplied and orfac is too small. if you Want to guarantee orthogonality (at the cos the following to lwork: 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. 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. Want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. make sure it's divisible by lcm (we Want even workloads! 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 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. 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. minimal workspace is supplied and orfac is too small. if you Want to guarantee orthogonality (at the cos the following to lwork: minimal workspace is supplied and orfac is too small. if you Want to guarantee orthogonality (at the cos the following to lwork: 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. 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. Want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. minimal workspace is supplied and orfac is too small. if you Want to guarantee orthogonality (at the cos the following to lrwork: minimal workspace is supplied and orfac is too small. if you Want to guarantee orthogonality (at the cos the following to lrwork: for schur form, use 2x2 blocks if we don't Want the schur form, use bigger blocks now the active submatrix is in rows and columns l to i. if 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 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. 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. |
| wanted wanted 1, if left(right) singular vectors are wanted 0, otherwise 1, if left(right) singular vectors are wanted 0, otherwise 1, if left(right) singular vectors are wanted 0, otherwise 1, if left(right) singular vectors are wanted 0, otherwise |
| WANTU WANTU wbdtosvd = size*(WANTU*nru + wantvt*ncvt) max(wantu*wpcormbrqln, wantvt*wpcormbrprt)), wbdtosvd = size*(WANTU*nru + wantvt*ncvt) max(wantu*wpdormbrqln, wantvt*wpdormbrprt)), wbdtosvd = size*(WANTU*nru + wantvt*ncvt) max(wantu*wpsormbrqln, wantvt*wpsormbrprt)), wbdtosvd = size*(WANTU*nru + wantvt*ncvt) max(wantu*wpzormbrqln, wantvt*wpzormbrprt)), |
| WANTVT WANTVT wbdtosvd = size*(wantu*nru + WANTVT*ncvt) max(wantu*wpcormbrqln, wantvt*wpcormbrprt)), wbdtosvd = size*(wantu*nru + WANTVT*ncvt) max(wantu*wpdormbrqln, wantvt*wpdormbrprt)), wbdtosvd = size*(wantu*nru + WANTVT*ncvt) max(wantu*wpsormbrqln, wantvt*wpsormbrprt)), wbdtosvd = size*(wantu*nru + WANTVT*ncvt) max(wantu*wpzormbrqln, wantvt*wpzormbrprt)), |
| WANTZ WANTZ WANTZ (global input) logica if .false., then do no additional work on z. WANTZ (global input) logica if .false., then do no additional work on z. WANTZ (global input) logica if .false., then do no additional work on z. WANTZ (global input) logica if .false., then do no additional work on z. |
| was was eigenvalues and things couldn't be paired or if the input matrix s was not originally in schur form if stopping criterion was not satisfied, update info an > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. if error was found in phase 1, processors jump here free blacs space used to hold standard-form grid. on exit, if ipiv(i) = k, the local i-th column of sub( a )*p was the global k-th column of sub( a ). ipiv is tied to th 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 6. if fact = 'e' and equilibration was used, the matrix x i trans = 't' or 'c') so that it solves the original system 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 send e-mail to scalapack@cs.utk.edu if (mod(info/16,2).ne.0), then b was not positiv the smallest minor which is not positive definite. the serial version clacon has been contributed by nick higham, university of manchester. it was originally named sonest, date the else part of this if needs updated vcopy, this was not necessary in pslahqr 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. equed (global output) character specifies the form of equilibration that was done = 'r': row equilibration, i.e., sub( a ) has been pre- equed (output) character*1 specifies whether or not equilibration was done = 'y': equilibration was done, i.e., sub( a ) has been re- compute x(j) := ( x(j) - csumj ) / a(j,j) if 1/a(j,j) was not used to scale the dotproduct x( j ) = x( j ) - csumj the serial version was contributed to lapack by nick higham for us > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. 6. if equilibration was used, the matrix x is premultiplied b equilibration. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. 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. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. if error was found in phase 1, processors jump here free blacs space used to hold standard-form grid. on exit, if ipiv(i) = k, the local i-th column of sub( a )*p was the global k-th column of sub( a ). ipiv is tied to th 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 6. if fact = 'e' and equilibration was used, the matrix x i trans = 't' or 'c') so that it solves the original system 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 the serial version dlacon has been contributed by nick higham, university of manchester. it was originally named sonest, date 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. equed (global output) character specifies the form of equilibration that was done = 'r': row equilibration, i.e., sub( a ) has been pre- equed (output) character*1 specifies whether or not equilibration was done = 'y': equilibration was done, i.e., sub( a ) has been re- > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. 6. if equilibration was used, the matrix x is premultiplied b equilibration. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. = 3 : range='i', and the gershgorin interval initially used was incorrect. no eigenvalues were computed point arithmetic. send e-mail to scalapack@cs.utk.edu if (mod(info/16,2).ne.0), then b was not positiv the smallest minor which is not positive definite. the serial version of this routine was originally contributed b the serial version of this routine was originally contributed b > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. if error was found in phase 1, processors jump here free blacs space used to hold standard-form grid. on exit, if ipiv(i) = k, the local i-th column of sub( a )*p was the global k-th column of sub( a ). ipiv is tied to th 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 6. if fact = 'e' and equilibration was used, the matrix x i trans = 't' or 'c') so that it solves the original system 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 the serial version slacon has been contributed by nick higham, university of manchester. it was originally named sonest, date 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. equed (global output) character specifies the form of equilibration that was done = 'r': row equilibration, i.e., sub( a ) has been pre- equed (output) character*1 specifies whether or not equilibration was done = 'y': equilibration was done, i.e., sub( a ) has been re- > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. 6. if equilibration was used, the matrix x is premultiplied b equilibration. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. = 3 : range='i', and the gershgorin interval initially used was incorrect. no eigenvalues were computed point arithmetic. send e-mail to scalapack@cs.utk.edu if (mod(info/16,2).ne.0), then b was not positiv the smallest minor which is not positive definite. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. if error was found in phase 1, processors jump here free blacs space used to hold standard-form grid. on exit, if ipiv(i) = k, the local i-th column of sub( a )*p was the global k-th column of sub( a ). ipiv is tied to th 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 6. if fact = 'e' and equilibration was used, the matrix x i trans = 't' or 'c') so that it solves the original system 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 send e-mail to scalapack@cs.utk.edu if (mod(info/16,2).ne.0), then b was not positiv the smallest minor which is not positive definite. the serial version zlacon has been contributed by nick higham, university of manchester. it was originally named sonest, date the else part of this if needs updated vcopy, this was not necessary in pdlahqr 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. equed (global output) character specifies the form of equilibration that was done = 'r': row equilibration, i.e., sub( a ) has been pre- equed (output) character*1 specifies whether or not equilibration was done = 'y': equilibration was done, i.e., sub( a ) has been re- compute x(j) := ( x(j) - csumj ) / a(j,j) if 1/a(j,j) was not used to scale the dotproduct x( j ) = x( j ) - csumj the serial version was contributed to lapack by nick higham for us > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. 6. if equilibration was used, the matrix x is premultiplied b equilibration. > 0: if info = k<=nprocs, the submatrix stored on processor info and factored locally was no the factorization was not completed. 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. eigenvalues and things couldn't be paired or if the input matrix s was not originally in schur form if stopping criterion was not satisfied, update info an |
| WATOBD WATOBD 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, |
| way way 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. parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error the traditional way of computing v (and the one used in pzlatrd.f an v = tau * v otherwise, scale column of a by uscal before dot product. below is not the best way to do it do 130 i = 1, j - 1 parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal largest entry in sub( x ). the estimate is as reliable as the estimate for rcond, and is almost always a sligh this array is tied to the distributed matrix x. parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal the traditional way of computing v (and the one used in pzlatrd.f an v = tau * v largest entry in sub( x ). the estimate is as reliable as the estimate for rcond, and is almost always a sligh this array is tied to the distributed matrix x. parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal the traditional way of computing v (and the one used in pzlatrd.f an v = tau * v largest entry in sub( x ). the estimate is as reliable as the estimate for rcond, and is almost always a sligh this array is tied to the distributed matrix x. parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error the traditional way of computing v (and the one used in pzlatrd.f an v = tau * v otherwise, scale column of a by uscal before dot product. below is not the best way to do it do 130 i = 1, j - 1 parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal parallel. these factors are applied to the matrix creating fillin, which is stored in a non-inspectable way in auxiliar the matrix a as p a p^t and then factoring the principal largest entry in sub( x ). the estimate is as reliable as the estimate for rcond, and is almost always a sligh this array is tied to the distributed matrix x. 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. |
| ways ways sorted set. then it tries to deflate the size of the problem. there are two ways in which deflation can occur: when two or mor z vector. for each such occurrence the order of the related secular sorted set. then it tries to deflate the size of the problem. there are two ways in which deflation can occur: when two or mor z vector. for each such occurrence the order of the related secular |
| WBDTOSVD WBDTOSVD 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, |
| WCBDSQR WCBDSQR wbdtosvd = size*(wantu*nru + wantvt*ncvt) + max(WCBDSQR |
| WDBDSQR WDBDSQR wbdtosvd = size*(wantu*nru + wantvt*ncvt) + max(WDBDSQR |
| well well ccombamax1 finds the element having maximum real part absolute value as well as its corresponding globl index arguments wantz (global input) logical if .true., then apply any column reflections to z as well wantz (global input) logical if .true., then apply any column reflections to z as well factors is not guaranteed to reduce the condition number of sub( a ) but works well in practice notes factors is not guaranteed to reduce the condition number of sub( a ) but works well in practice notes factors is not guaranteed to reduce the condition number of sub( a ) but works well in practice notes factors is not guaranteed to reduce the condition number of sub( a ) but works well in practice notes wantz (global input) logical if .true., then apply any column reflections to z as well zcombamax1 finds the element having maximum real part absolute value as well as its corresponding globl index arguments wantz (global input) logical if .true., then apply any column reflections to z as well |
| were were locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a zero out any junk entries that were copie locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a assume that its process grid has dimension r x c. locr( k ) denotes the number of elements of k that a process would receive if k were locc( k ) denotes the number of elements of k that a process would locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locp( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locq( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a zero out any junk entries that were copie locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a assume that its process grid has dimension r x c. locr( k ) denotes the number of elements of k that a process would receive if k were locc( k ) denotes the number of elements of k that a process would locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a = 1 - mmax : the last info intervals did not converge. = mmax + 1 : more than mmax intervals were generated ===================================================================== on exit, d contains the trailing (n-k) updated eigenvalues (those which were deflated) sorted into increasing order drow (global input) integer on exit, d contains the trailing (n-k) updated eigenvalues (those which were deflated) sorted into increasing order drow (global input) integer locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a > 0 : some or all of the eigenvalues failed to converge or were not computed these eigenvalues are flagged by a negative block locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locp( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locq( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a zero out any junk entries that were copie locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a assume that its process grid has dimension r x c. locr( k ) denotes the number of elements of k that a process would receive if k were locc( k ) denotes the number of elements of k that a process would locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a = 1 - mmax : the last info intervals did not converge. = mmax + 1 : more than mmax intervals were generated ===================================================================== on exit, d contains the trailing (n-k) updated eigenvalues (those which were deflated) sorted into increasing order drow (global input) integer on exit, d contains the trailing (n-k) updated eigenvalues (those which were deflated) sorted into increasing order drow (global input) integer locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a > 0 : some or all of the eigenvalues failed to converge or were not computed these eigenvalues are flagged by a negative block locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locp( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locq( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a zero out any junk entries that were copie locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a assume that its process grid has dimension r x c. locr( k ) denotes the number of elements of k that a process would receive if k were locc( k ) denotes the number of elements of k that a process would locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locp( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locq( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a |
| what what (only the first nsplit elements will actually be used, but since the user cannot know a priori what value nsplit wil (only the first nsplit elements will actually be used, but since the user cannot know a priori what value nsplit wil |
| whatever whatever processors, the first major loop (10) goes over the tridiagonal and has each node store whatever values of the 7 it has tha and can happen in no more than 3 locations per block assuming processors, the first major loop (10) goes over the tridiagonal and has each node store whatever values of the 7 it has tha and can happen in no more than 3 locations per block assuming processors, the first major loop (10) goes over the tridiagonal and has each node store whatever values of the 7 it has tha and can happen in no more than 3 locations per block assuming processors, the first major loop (10) goes over the tridiagonal and has each node store whatever values of the 7 it has tha and can happen in no more than 3 locations per block assuming |
| when when the band storage scheme is illustrated by the following example, when 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 these serve the same purpose as itmp1,itmp2 but for z when wantz is set vecs (global input) complex array of size 3*n (matrix size) the band storage scheme is illustrated by the following example, when 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 these serve the same purpose as itmp1,itmp2 but for z when wantz is set vecs (global input) double precision array of size 3*n (matrix where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n vectors b and solution vectors x can be handled in a single call; this routine temporarily returns when n <= 1 the distributed submatrices op( a ) and op( af ) (respectively to pcunmbr. nru is equal to the local number of rows of the matrix u when distributed 1-dimensional "column" o of columns of the matrix vt when distributed across an approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b an approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b pchengst calls pchegst when uplo='u', hence pchengst provide codes (either the serial, chetrd, or the parallel code, pchettrd) when the workspace provided by the user is adequate we first hit a border when mod(k1(ki)-1,hbl)=hbl-2 and we hi i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. 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 following restrictions apply when ipiv must be transposed descip(mb_) must equal desca(nb_) scale x by (1/abs(x(j)))*abs(a(j,j))*bignum to avoid overflow when dividing by a(j,j) 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). pcporfs improves the computed solution to a system of linear equations when the coefficient matrix is hermitian positive definit solutions. this routine temporarily returns when n <= 1 the distributed submatrices sub( x ) and sub( b ) should be here q and p**h are the unitary distributed matrices determined by pcgebrd when reducing a complex distributed matrix a(ia:*,ja:*) t as products of elementary reflectors h(i) and g(i) respectively. where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n vectors b and solution vectors x can be handled in a single call; this routine temporarily returns when n <= 1 the distributed submatrices op( a ) and op( af ) (respectively to pdormbr. nru is equal to the local number of rows of the matrix u when distributed 1-dimensional "column" o of columns of the matrix vt when distributed across abstol (input) double precision the minimum (absolute) width of an interval. when an interva magnitude) endpoint, then it is considered to be sufficiently specifies the criterion for "convergence" of an interval. = 0 : when an interval is narrower than abstol, or tha it is considered to have "converged". the first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero i secular equation problem is reduced by one. this stage is sorted set. then it tries to deflate the size of the problem. there are two ways in which deflation can occur: when two or mor z vector. for each such occurrence the order of the related secular we first hit a border when mod(k1(ki)-1,hbl)=hbl-2 and we hi t = number of (base) digits in the mantissa rnd = 1.0 when rounding occurs in addition, 0.0 otherwis rmin = underflow threshold - base**(emin-1) i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. 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 following restrictions apply when ipiv must be transposed descip(mb_) must equal desca(nb_) here q and p**t are the orthogonal distributed matrices determined by pdgebrd when reducing a real distributed matrix a(ia:*,ja:*) t as products of elementary reflectors h(i) and g(i) respectively. pdporfs improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definit solutions. will be used, where |t| means the 1-norm of t. eigenvalues will be computed most accurately when abstol i note : if eigenvectors are desired later by inverse iteration sizemqrleft = the workspace requirement for pdormtr when it's side argument is 'l' with myprowc defined when a new context is created as: an approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b an approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b pdsyngst calls pdhegst when uplo='u', hence pdhengst provide codes (either the serial, dsytrd, or the parallel code, pdsyttrd) when the workspace provided by the user is adequate this routine temporarily returns when n <= 1 the distributed submatrices sub( x ) and sub( b ) should be 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). the following conventions have been used when calling pjlaenv fro 1) opts is a concatenation of all of the character options to 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). where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n vectors b and solution vectors x can be handled in a single call; this routine temporarily returns when n <= 1 the distributed submatrices op( a ) and op( af ) (respectively to psormbr. nru is equal to the local number of rows of the matrix u when distributed 1-dimensional "column" o of columns of the matrix vt when distributed across abstol (input) real the minimum (absolute) width of an interval. when an interva magnitude) endpoint, then it is considered to be sufficiently specifies the criterion for "convergence" of an interval. = 0 : when an interval is narrower than abstol, or tha it is considered to have "converged". the first stage consists of deflating the size of the problem when there are multiple eigenvalues or if there is a zero i secular equation problem is reduced by one. this stage is sorted set. then it tries to deflate the size of the problem. there are two ways in which deflation can occur: when two or mor z vector. for each such occurrence the order of the related secular we first hit a border when mod(k1(ki)-1,hbl)=hbl-2 and we hi t = number of (base) digits in the mantissa rnd = 1.0 when rounding occurs in addition, 0.0 otherwis rmin = underflow threshold - base**(emin-1) i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. 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 following restrictions apply when ipiv must be transposed descip(mb_) must equal desca(nb_) here q and p**t are the orthogonal distributed matrices determined by psgebrd when reducing a real distributed matrix a(ia:*,ja:*) t as products of elementary reflectors h(i) and g(i) respectively. psporfs improves the computed solution to a system of linear equations when the coefficient matrix is symmetric positive definit solutions. will be used, where |t| means the 1-norm of t. eigenvalues will be computed most accurately when abstol i note : if eigenvectors are desired later by inverse iteration sizemqrleft = the workspace requirement for psormtr when it's side argument is 'l' with myprowc defined when a new context is created as: an approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b an approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b pssyngst calls pshegst when uplo='u', hence pshengst provide codes (either the serial, ssytrd, or the parallel code, pssyttrd) when the workspace provided by the user is adequate this routine temporarily returns when n <= 1 the distributed submatrices sub( x ) and sub( b ) should be where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n vectors b and solution vectors x can be handled in a single call; this routine temporarily returns when n <= 1 the distributed submatrices op( a ) and op( af ) (respectively to pzunmbr. nru is equal to the local number of rows of the matrix u when distributed 1-dimensional "column" o of columns of the matrix vt when distributed across an approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b an approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b pzhengst calls pzhegst when uplo='u', hence pzhengst provide codes (either the serial, zhetrd, or the parallel code, pzhettrd) when the workspace provided by the user is adequate we first hit a border when mod(k1(ki)-1,hbl)=hbl-2 and we hi i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. 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 following restrictions apply when ipiv must be transposed descip(mb_) must equal desca(nb_) scale x by (1/abs(x(j)))*abs(a(j,j))*bignum to avoid overflow when dividing by a(j,j) 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). pzporfs improves the computed solution to a system of linear equations when the coefficient matrix is hermitian positive definit solutions. this routine temporarily returns when n <= 1 the distributed submatrices sub( x ) and sub( b ) should be here q and p**h are the unitary distributed matrices determined by pzgebrd when reducing a complex distributed matrix a(ia:*,ja:*) t as products of elementary reflectors h(i) and g(i) respectively. the band storage scheme is illustrated by the following example, when 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 these serve the same purpose as itmp1,itmp2 but for z when wantz is set vecs (global input) real array of size 3*n (matrix the band storage scheme is illustrated by the following example, when 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 these serve the same purpose as itmp1,itmp2 but for z when wantz is set vecs (global input) complex*16 array of size 3*n (matrix size) |
| where where a = l * u where l is a product of unit lower bidiagona diagonal and first superdiagonal. u * x = b, or u**h * x = b, where l or u is the cholesky factor of a hermitian positiv a = u**h*d*u or a = l*d*l**h (computed by cpttrf). where x is an n element vector and t is an n by a = l * u where l is a product of unit lower bidiagona diagonal and first superdiagonal. l**t* x = b, or l * x = b, where l is the cholesky factor of a hermitian positiv a = l*d*l**h (computed by dpttrf). determine where the matrix splits and choose ql or qr iteratio element is smaller. where x is an n element vector and t is an n by where a(1:n, ja:ja+n-1) is an n-by-n comple matrix with bandwidth bwl, bwu. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is an n-by-n comple matrix. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is an n-by-n comple matrix with bandwidth bwl, bwu. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex where nb = mb_a = nb_a, iroffa = mod( ia-1, nb iacol = indxg2p( ja, nb, mycol, csrc_a, npcol ), where nb = mb_a = nb_a iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ), to upper hessenberg form h by an unitary similarity transformation: q' * sub( a ) * q = h, where to upper hessenberg form h by an unitary similarity transformation: q' * sub( a ) * q = h, where lwork is local input and must be at least lwork >= nq0 + max( 1, mp0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mp0 + nq0 + mb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n vectors b and solution vectors x can be handled in a single call; lwork is local input and must be at least lwork >= mp0 + max( 1, nq0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( mp0 + nq0 + nb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where tau is a complex scalar, and v is a complex vector wit a(ia+i-1:ia+m-1,ja+i-1). lwork is local input and must be at least lwork >= mp0 + max( 1, nq0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( mp0 + nq0 + nb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nq0 + max( 1, mp0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mp0 + nq0 + mb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distribute distributed matrices. where sigma is an m-by-n matrix which is zero except for it v is an n-by-n orthogonal matrix. the diagonal elements of sigma where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an the factorization has the form sub( a ) = p * l * u, where p is elements (lower trapezoidal if m > n), and u is upper triangular the factorization has the form sub( a ) = p * l * u, where p is ments (lower trapezoidal if m > n), and u is upper triangular nb_a ) where lcm is the least common multiple of proces end if where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix iarow.eq.izrow ) where where eps is the machine precision. if abstol is less tha where norm(t) is the 1-norm of the tridiagonal matrix where eps is the machine precision. if abstol is less tha where norm(t) is the 1-norm of the tridiagonal matrix where nb = mb_a = nb_a nq0 = numroc( n, nb, 0, 0, nprow ), tridiagonal form t by an unitary similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) features tridiagonal form t by an unitary similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes tridiagonal form t by an unitary similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes tridiagonal form t by an unitary similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes where tauq and taup are complex scalars, and v and u are comple pclacgv conjugates a complex vector of length n, sub( x ), where x(ix:ix+n-1,jx) if incx = 1, and memory to an array of dimension locr(n+mod(iv-1,mb_v)). on the final return, v = a*w, where est = norm(v)/norm(w up and left and a buffer to send right. each of these buffers is actually stored in one buffer buf where buf(istr1+1) start the values are stored, if there are any values that a node 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 pclaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli where tau is a complex scalar, and v is a complex vector wit a(ia+i+k:ia+n-1,ja+i-1), and tau in tau(ja+i-1). 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 ipiv (local input) integer array, dimension (lipiv) where lipiv i >= locr( ia+m-1 ) + mb_a if pivroc='c' or 'c', where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), 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 where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ) ssq will then satisfy where tau is a complex scalar, and v is a complex vector wit a(ia:ia+i-2,ja+i), and tau in tau(ja+i-1). where z is an n-by-n unitary matrix and r is an m-by-m uppe
compute grow = 1/g(j), where g(0) = max{x(i), i=1,...,n}
pclauu2 computes the product u * u' or l' * l, where the triangula the matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pclauum computes the product u * u' or l' * l, where the triangula the distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). m (global input) integer on entry, this is where the transform starts (row m. where sub( x ) denotes x(ix:ix+n-1,jx) if incx = 1 where a(1:n, ja:ja+n-1) is an n-by-n comple matrix with bandwidth bw. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is an n-by- denoting b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs distributed where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an where u is an upper triangular matrix and l is lower triangular notes where u is an upper triangular matrix and l is lower triangular notes where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a n-by- factorization sub( a ) = u**h*u or l*l**h computed by pcpotrf. where a(1:n, ja:ja+n-1) is an n-by-n comple matrix. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where sub( x ) denotes x(ix:ix+n-1,jx:jx), if incx = 1 where y' denotes the conjugate transpose of the vector y if all eigenvectors are requested, the routine may either return the where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a triangula n-by-nrhs distributed matrix denoted by sub( b ). a check is made where z is an n-by-n unitary matrix and r is an m-by-m uppe lwork is local input and must be at least lwork >= mpa0 + max( 1, nqa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mpa0 + max( 1, nqa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nqa0 + max( 1, mpa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mpa0 + nqa0 + mb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( nqa0 + mpa0 + nb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( nqa0 + mpa0 + nb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nqa0 + max( 1, mpa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mpa0 + nqa0 + mb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where lcmp = lcm / nprow, lcmq = lcm / npcol, wit where q is a complex unitary distributed matrix of order nq, wit product of ihi-ilo elementary reflectors, as returned by pcgehrd: where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix of order nq, wit product of nq-1 elementary reflectors, as returned by pchetrd: where a(1:n, ja:ja+n-1) is an n-by-n rea matrix with bandwidth bwl, bwu. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is an n-by-n rea matrix. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is an n-by-n rea matrix with bandwidth bwl, bwu. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real where nb = mb_a = nb_a, iroffa = mod( ia-1, nb iacol = indxg2p( ja, nb, mycol, csrc_a, npcol ), where nb = mb_a = nb_a iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ), to upper hessenberg form h by an orthogonal similarity transforma- tion: q' * sub( a ) * q = h, where to upper hessenberg form h by an orthogonal similarity transforma- tion: q' * sub( a ) * q = h, where lwork is local input and must be at least lwork >= nq0 + max( 1, mp0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mp0 + nq0 + mb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n vectors b and solution vectors x can be handled in a single call; lwork is local input and must be at least lwork >= mp0 + max( 1, nq0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( mp0 + nq0 + nb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where tau is a real scalar, and v is a real vector with v(1:i-1) = lwork is local input and must be at least lwork >= mp0 + max( 1, nq0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( mp0 + nq0 + nb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nq0 + max( 1, mp0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mp0 + nq0 + mb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distribute distributed matrices. where sigma is an m-by-n matrix which is zero except for it v is an n-by-n orthogonal matrix. the diagonal elements of sigma where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an the factorization has the form sub( a ) = p * l * u, where p is elements (lower trapezoidal if m > n), and u is upper triangular the factorization has the form sub( a ) = p * l * u, where p is ments (lower trapezoidal if m > n), and u is upper triangular nb_a ) where lcm is the least common multiple of proces end if where q is an n-by-n orthogonal matrix, z is a p-by-p orthogona where q is an n-by-n orthogonal matrix, z is a p-by-p orthogona 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 memory to an array of dimension locr(n+mod(iv-1,mb_v)). on the final return, v = a*w, where est = norm(v)/norm(w up and left and a buffer to send right. each of these buffers is actually stored in one buffer buf where buf(istr1+1) start the values are stored, if there are any values that a node 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 pdlaebz contains the iteration loop which computes the eigenvalues contained in the input intervals [ intvl(2*j-1), intvl(2*j) ] where the count of eigenvalues of a symmetric tridiagonal matrix less than where z = q'u, u is a vector of length n with ones in th pdlaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli where tau is a real scalar, and v is a real vector wit a(ia+i+k:ia+n-1,ja+i-1), and tau in tau(ja+i-1). where eps = relative machine precision 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 implementation of the sturm sequence loop. this must be at least max_j |e(j)^2| *safe_min, and at least safe_min, where without overflow. ipiv (local input) integer array, dimension (lipiv) where lipiv i >= locr( ia+m-1 ) + mb_a if pivroc='c' or 'c', where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), where alpha is a scalar, and sub( x ) is an (n-1)-element rea incx = descx(m_). h is represented in the form where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), lwork = max( n, np * ( nb + nq )) where nq = numroc( n, nb, mycol, descq( csrc_ ), npcol ) where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ) value where tau is a real scalar, and v is a real vector wit a(ia:ia+i-2,ja+i), and tau in tau(ja+i-1). where z is an n-by-n orthogonal matrix and r is an m-by-m uppe pdlauu2 computes the product u * u' or l' * l, where the triangula the matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pdlauum computes the product u * u' or l' * l, where the triangula the distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). m (global input) integer on entry, this is where the transform starts (row m. lwork is local input and must be at least lwork >= mpa0 + max( 1, nqa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mpa0 + max( 1, nqa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nqa0 + max( 1, mpa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mpa0 + nqa0 + mb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( nqa0 + mpa0 + nb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( nqa0 + mpa0 + nb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nqa0 + max( 1, mpa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mpa0 + nqa0 + mb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where lcmp = lcm / nprow, lcmq = lcm / npcol, wit where q is a real orthogonal distributed matrix of order nq, wit product of ihi-ilo elementary reflectors, as returned by pdgehrd: where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix of order nq, wit product of nq-1 elementary reflectors, as returned by pdsytrd: where a(1:n, ja:ja+n-1) is an n-by-n rea matrix with bandwidth bw. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is an n-by- denoting b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs distributed where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an where u is an upper triangular matrix and l is lower triangular notes where u is an upper triangular matrix and l is lower triangular notes where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a n-by- factorization sub( a ) = u**t*u or l*l**t computed by pdpotrf. where a(1:n, ja:ja+n-1) is an n-by-n rea matrix. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where sub( x ) denotes x(ix:ix+n-1,jx:jx), if incx = 1 less. if abstol is less than or equal to zero, then ulp*|t|
will be used, where |t| means the 1-norm of t
set to the underflow threshold dlamch('u'), not zero.
lwork >= 5*n + sizesytrd + 1 where and is max( nb * ( np +1 ), 3 * nb ) where eps is the machine precision. if abstol is less tha where norm(t) is the 1-norm of the tridiagonal matrix where eps is the machine precision. if abstol is less tha where norm(t) is the 1-norm of the tridiagonal matrix where nb = mb_a = nb_a nq0 = numroc( n, nb, 0, 0, nprow ), tridiagonal form t by an orthogonal similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) features tridiagonal form t by an orthogonal similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes tridiagonal form t by an orthogonal similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes tridiagonal form t by an unitary similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a triangula n-by-nrhs distributed matrix denoted by sub( b ). a check is made where z is an n-by-n orthogonal matrix and r is an m-by-m uppe where sub( x ) denotes x(ix:ix+n-1,jx:jx), if incx = 1 where sub( x ) denotes x(ix:ix+n-1,jx:jx), if incx = 1 where a(1:n, ja:ja+n-1) is an n-by-n rea matrix with bandwidth bwl, bwu. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is an n-by-n rea matrix. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is an n-by-n rea matrix with bandwidth bwl, bwu. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real where nb = mb_a = nb_a, iroffa = mod( ia-1, nb iacol = indxg2p( ja, nb, mycol, csrc_a, npcol ), where nb = mb_a = nb_a iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ), to upper hessenberg form h by an orthogonal similarity transforma- tion: q' * sub( a ) * q = h, where to upper hessenberg form h by an orthogonal similarity transforma- tion: q' * sub( a ) * q = h, where lwork is local input and must be at least lwork >= nq0 + max( 1, mp0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mp0 + nq0 + mb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n vectors b and solution vectors x can be handled in a single call; lwork is local input and must be at least lwork >= mp0 + max( 1, nq0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( mp0 + nq0 + nb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where tau is a real scalar, and v is a real vector with v(1:i-1) = lwork is local input and must be at least lwork >= mp0 + max( 1, nq0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( mp0 + nq0 + nb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nq0 + max( 1, mp0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mp0 + nq0 + mb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distribute distributed matrices. where sigma is an m-by-n matrix which is zero except for it v is an n-by-n orthogonal matrix. the diagonal elements of sigma where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an the factorization has the form sub( a ) = p * l * u, where p is elements (lower trapezoidal if m > n), and u is upper triangular the factorization has the form sub( a ) = p * l * u, where p is ments (lower trapezoidal if m > n), and u is upper triangular nb_a ) where lcm is the least common multiple of proces end if where q is an n-by-n orthogonal matrix, z is a p-by-p orthogona where q is an n-by-n orthogonal matrix, z is a p-by-p orthogona 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 memory to an array of dimension locr(n+mod(iv-1,mb_v)). on the final return, v = a*w, where est = norm(v)/norm(w up and left and a buffer to send right. each of these buffers is actually stored in one buffer buf where buf(istr1+1) start the values are stored, if there are any values that a node 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 pslaebz contains the iteration loop which computes the eigenvalues contained in the input intervals [ intvl(2*j-1), intvl(2*j) ] where the count of eigenvalues of a symmetric tridiagonal matrix less than where z = q'u, u is a vector of length n with ones in th pslaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli where tau is a real scalar, and v is a real vector wit a(ia+i+k:ia+n-1,ja+i-1), and tau in tau(ja+i-1). where eps = relative machine precision 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 implementation of the sturm sequence loop. this must be at least max_j |e(j)^2| *safe_min, and at least safe_min, where without overflow. ipiv (local input) integer array, dimension (lipiv) where lipiv i >= locr( ia+m-1 ) + mb_a if pivroc='c' or 'c', where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), where alpha is a scalar, and sub( x ) is an (n-1)-element rea incx = descx(m_). h is represented in the form where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), lwork = max( n, np * ( nb + nq )) where nq = numroc( n, nb, mycol, descq( csrc_ ), npcol ) where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ) value where tau is a real scalar, and v is a real vector wit a(ia:ia+i-2,ja+i), and tau in tau(ja+i-1). where z is an n-by-n orthogonal matrix and r is an m-by-m uppe pslauu2 computes the product u * u' or l' * l, where the triangula the matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pslauum computes the product u * u' or l' * l, where the triangula the distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). m (global input) integer on entry, this is where the transform starts (row m. lwork is local input and must be at least lwork >= mpa0 + max( 1, nqa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mpa0 + max( 1, nqa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nqa0 + max( 1, mpa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mpa0 + nqa0 + mb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( nqa0 + mpa0 + nb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( nqa0 + mpa0 + nb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nqa0 + max( 1, mpa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mpa0 + nqa0 + mb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where lcmp = lcm / nprow, lcmq = lcm / npcol, wit where q is a real orthogonal distributed matrix of order nq, wit product of ihi-ilo elementary reflectors, as returned by psgehrd: where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix defined as th where q is a real orthogonal distributed matrix of order nq, wit product of nq-1 elementary reflectors, as returned by pssytrd: where a(1:n, ja:ja+n-1) is an n-by-n rea matrix with bandwidth bw. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is an n-by- denoting b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs distributed where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an where u is an upper triangular matrix and l is lower triangular notes where u is an upper triangular matrix and l is lower triangular notes where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a n-by- factorization sub( a ) = u**t*u or l*l**t computed by pspotrf. where a(1:n, ja:ja+n-1) is an n-by-n rea matrix. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n real form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where sub( x ) denotes x(ix:ix+n-1,jx:jx), if incx = 1 less. if abstol is less than or equal to zero, then ulp*|t|
will be used, where |t| means the 1-norm of t
set to the underflow threshold slamch('u'), not zero.
lwork >= 5*n + sizesytrd + 1 where and is max( nb * ( np +1 ), 3 * nb ) where eps is the machine precision. if abstol is less tha where norm(t) is the 1-norm of the tridiagonal matrix where eps is the machine precision. if abstol is less tha where norm(t) is the 1-norm of the tridiagonal matrix where nb = mb_a = nb_a nq0 = numroc( n, nb, 0, 0, nprow ), tridiagonal form t by an orthogonal similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) features tridiagonal form t by an orthogonal similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes tridiagonal form t by an orthogonal similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes tridiagonal form t by an unitary similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a triangula n-by-nrhs distributed matrix denoted by sub( b ). a check is made where z is an n-by-n orthogonal matrix and r is an m-by-m uppe where a(1:n, ja:ja+n-1) is an n-by-n comple matrix with bandwidth bwl, bwu. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where sub( x ) denotes x(ix:ix+n-1,jx:jx), if incx = 1 where a(1:n, ja:ja+n-1) is an n-by-n comple matrix. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is an n-by-n comple matrix with bandwidth bwl, bwu. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex where nb = mb_a = nb_a, iroffa = mod( ia-1, nb iacol = indxg2p( ja, nb, mycol, csrc_a, npcol ), where nb = mb_a = nb_a iarow = indxg2p( ia, nb, myrow, rsrc_a, nprow ), to upper hessenberg form h by an unitary similarity transformation: q' * sub( a ) * q = h, where to upper hessenberg form h by an unitary similarity transformation: q' * sub( a ) * q = h, where lwork is local input and must be at least lwork >= nq0 + max( 1, mp0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mp0 + nq0 + mb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where sub( b ) denotes b( ib:ib+m-1, jb:jb+nrhs-1 ) when trans = 'n vectors b and solution vectors x can be handled in a single call; lwork is local input and must be at least lwork >= mp0 + max( 1, nq0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( mp0 + nq0 + nb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where tau is a complex scalar, and v is a complex vector wit a(ia+i-1:ia+m-1,ja+i-1). lwork is local input and must be at least lwork >= mp0 + max( 1, nq0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( mp0 + nq0 + nb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nq0 + max( 1, mp0 ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mp0 + nq0 + mb_a ), where iroff = mod( ia-1, mb_a ), icoff = mod( ja-1, nb_a ), where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distribute distributed matrices. where sigma is an m-by-n matrix which is zero except for it v is an n-by-n orthogonal matrix. the diagonal elements of sigma where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an the factorization has the form sub( a ) = p * l * u, where p is elements (lower trapezoidal if m > n), and u is upper triangular the factorization has the form sub( a ) = p * l * u, where p is ments (lower trapezoidal if m > n), and u is upper triangular nb_a ) where lcm is the least common multiple of proces end if where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix iarow.eq.izrow ) where where eps is the machine precision. if abstol is less tha where norm(t) is the 1-norm of the tridiagonal matrix where eps is the machine precision. if abstol is less tha where norm(t) is the 1-norm of the tridiagonal matrix where nb = mb_a = nb_a nq0 = numroc( n, nb, 0, 0, nprow ), tridiagonal form t by an unitary similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) features tridiagonal form t by an unitary similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes tridiagonal form t by an unitary similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes tridiagonal form t by an unitary similarity transformation: q' * sub( a ) * q = t, where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) notes where tauq and taup are complex scalars, and v and u are comple pzlacgv conjugates a complex vector of length n, sub( x ), where x(ix:ix+n-1,jx) if incx = 1, and memory to an array of dimension locr(n+mod(iv-1,mb_v)). on the final return, v = a*w, where est = norm(v)/norm(w up and left and a buffer to send right. each of these buffers is actually stored in one buffer buf where buf(istr1+1) start the values are stored, if there are any values that a node 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 pzlaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli where tau is a complex scalar, and v is a complex vector wit a(ia+i+k:ia+n-1,ja+i-1), and tau in tau(ja+i-1). 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 ipiv (local input) integer array, dimension (lipiv) where lipiv i >= locr( ia+m-1 ) + mb_a if pivroc='c' or 'c', where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), 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 where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ) ssq will then satisfy where tau is a complex scalar, and v is a complex vector wit a(ia:ia+i-2,ja+i), and tau in tau(ja+i-1). where z is an n-by-n unitary matrix and r is an m-by-m uppe
compute grow = 1/g(j), where g(0) = max{x(i), i=1,...,n}
pzlauu2 computes the product u * u' or l' * l, where the triangula the matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). pzlauum computes the product u * u' or l' * l, where the triangula the distributed matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). m (global input) integer on entry, this is where the transform starts (row m. where sub( x ) denotes x(ix:ix+n-1,jx) if incx = 1 where a(1:n, ja:ja+n-1) is an n-by-n comple matrix with bandwidth bw. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is an n-by- denoting b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs distributed where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an where u is an upper triangular matrix and l is lower triangular notes where u is an upper triangular matrix and l is lower triangular notes where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a n-by- factorization sub( a ) = u**h*u or l*l**h computed by pzpotrf. where a(1:n, ja:ja+n-1) is an n-by-n comple matrix. form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where a(1:n, ja:ja+n-1) is the matrix used to produce the factor a(1:n, ja:ja+n-1) is an n-by-n complex form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted where y' denotes the conjugate transpose of the vector y if all eigenvectors are requested, the routine may either return the where sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1) and is a triangula n-by-nrhs distributed matrix denoted by sub( b ). a check is made where z is an n-by-n unitary matrix and r is an m-by-m uppe lwork is local input and must be at least lwork >= mpa0 + max( 1, nqa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mpa0 + max( 1, nqa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nqa0 + max( 1, mpa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mpa0 + nqa0 + mb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( nqa0 + mpa0 + nb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nb_a * ( nqa0 + mpa0 + nb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= nqa0 + max( 1, mpa0 ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), lwork is local input and must be at least lwork >= mb_a * ( mpa0 + nqa0 + mb_a ), where iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where lcmp = lcm / nprow, lcmq = lcm / npcol, wit where q is a complex unitary distributed matrix of order nq, wit product of ihi-ilo elementary reflectors, as returned by pzgehrd: where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix defined as th where q is a complex unitary distributed matrix of order nq, wit product of nq-1 elementary reflectors, as returned by pzhetrd: a = l * u where l is a product of unit lower bidiagona diagonal and first superdiagonal. l**t* x = b, or l * x = b, where l is the cholesky factor of a hermitian positiv a = l*d*l**h (computed by spttrf). determine where the matrix splits and choose ql or qr iteratio element is smaller. where x is an n element vector and t is an n by a = l * u where l is a product of unit lower bidiagona diagonal and first superdiagonal. u * x = b, or u**h * x = b, where l or u is the cholesky factor of a hermitian positiv a = u**h*d*u or a = l*d*l**h (computed by zpttrf). where x is an n element vector and t is an n by |
| whereas whereas work required in updating the current column of a. updating the block column of a is reasonably load balanced whereas processor column is involved). work required in updating the current column of a. updating the block column of a is reasonably load balanced whereas processor column is involved). work required in updating the current column of a. updating the block column of a is reasonably load balanced whereas processor column is involved). work required in updating the current column of a. updating the block column of a is reasonably load balanced whereas processor column is involved). |
| whether whether uplo (input) character*1 specifies whether to solve with l or u trans (input) character 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 determine where the matrix splits and choose ql or qr iteration for each block, according to whether top or bottom diagona 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 = 'c': (diag(r)*a*diag(c))**h *inv(diag(r))*x = diag(c)*b whether or not the system will be equilibrated depends on th overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n') 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. 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 on an intermediate return, kase will be 1 or 2, indicating whether x should be overwritten by a * x or a' * x pivroc (global input) character*1 specifies whether ipiv is distributed over a process ro = 'r' ipiv distributed over a process row 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*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 diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b whether or not the system will be equilibrated depends on th overwritten by diag(sr)*a*diag(sc) and b by diag(sr)*b. norm (global input) character specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm; uplo (global input) character specifies whether the distributed matrix sub( a ) is uppe = 'u': upper triangular, norm (global input) character specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm trans = 'c': (diag(r)*a*diag(c))**h *inv(diag(r))*x = diag(c)*b whether or not the system will be equilibrated depends on th overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n') on an intermediate return, kase will be 1 or 2, indicating whether x should be overwritten by a * x or a' * x ieflag (input) integer a flag which indicates whether n(w) should be speeded up b pivroc (global input) character*1 specifies whether ipiv is distributed over a process ro = 'r' ipiv distributed over a process row 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*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 diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b whether or not the system will be equilibrated depends on th overwritten by diag(sr)*a*diag(sc) and b by diag(sr)*b. 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. 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; uplo (global input) character specifies whether the distributed matrix sub( a ) is uppe = 'u': upper triangular, norm (global input) character specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm trans = 'c': (diag(r)*a*diag(c))**h *inv(diag(r))*x = diag(c)*b whether or not the system will be equilibrated depends on th overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n') on an intermediate return, kase will be 1 or 2, indicating whether x should be overwritten by a * x or a' * x ieflag (input) integer a flag which indicates whether n(w) should be speeded up b pivroc (global input) character*1 specifies whether ipiv is distributed over a process ro = 'r' ipiv distributed over a process row 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*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 diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b whether or not the system will be equilibrated depends on th overwritten by diag(sr)*a*diag(sc) and b by diag(sr)*b. 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. 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; uplo (global input) character specifies whether the distributed matrix sub( a ) is uppe = 'u': upper triangular, norm (global input) character specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm trans = 'c': (diag(r)*a*diag(c))**h *inv(diag(r))*x = diag(c)*b whether or not the system will be equilibrated depends on th overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n') 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. 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 on an intermediate return, kase will be 1 or 2, indicating whether x should be overwritten by a * x or a' * x pivroc (global input) character*1 specifies whether ipiv is distributed over a process ro = 'r' ipiv distributed over a process row 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*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 diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b whether or not the system will be equilibrated depends on th overwritten by diag(sr)*a*diag(sc) and b by diag(sr)*b. norm (global input) character specifies whether the 1-norm condition number or th = '1' or 'o': 1-norm; uplo (global input) character specifies whether the distributed matrix sub( a ) is uppe = 'u': upper triangular, uplo (input) character*1 specifies whether to solve with l or u trans (input) character determine where the matrix splits and choose ql or qr iteration for each block, according to whether top or bottom diagona 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 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 |
| which which here a11, a21 and a31 denote the current block of jb columns which is about to be factorized. the number of rows in th of columns are jb, j2, j3. the superdiagonal elements of a13 i1 and i2 are the indices of the first row and last column of h to which transformations must be applied. if eigenvalues only ar here a11, a21 and a31 denote the current block of jb columns which is about to be factorized. the number of rows in th of columns are jb, j2, j3. the superdiagonal elements of a13 the index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of the index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of the index in the global array a that points to the start of the matrix to be operated on (which may be either all of note that for mycol > 0 one has lower triangular blocks! lm is the number of rows which is usually nb except fo is nr+bwu where nr is the number of columns on the last processor the index in the global array a that points to the start of the matrix to be operated on (which may be either all of 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 where sigma is an m-by-n matrix which is zero except for it v is an n-by-n orthogonal matrix. the diagonal elements of sigma 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 a. rsrc_a (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the ia (global input) integer a's global row index, which points to the beginning of th 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 pchengst performs the same function as pchegst, but is based on rank 2k updates, which are faster and more scalable tha pchentrd is a prototype version of pchetrd which uses tailore when the workspace provided by the user is adequate. 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 distribute the columns of the array. rsrc_a (global) desca( rsrc_ ) the process row over which th csrc_a (global) desca( csrc_ ) the process column over which the or lower bidiagonal form by an unitary transformation q' * a * p, and returns the matrices x and y which are needed to apply the transfor 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 i1 and i2 are the indices of the first row and last column of h to which transformations must be applied. if eigenvalues only ar performed by an unitary similarity transformation q' * a * q. the routine returns the matrices v and t which determine q as a bloc ia (global input) integer a's global row index, which points to the beginning o 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 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 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 pclarft forms the triangular factor t of a complex block reflector h of order n, which is defined as a product of k elementary reflectors if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular; 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 pclarzt forms the triangular factor t of a complex block reflector h of order > n, which is defined as a product of k elementar 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 tridiagonal form by an unitary similarity transformation q' * sub( a ) * q, and returns the matrices v and w which ar 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of te 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 pcung2l generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pcung2r generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pcungl2 generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pcunglq generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pcungql generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pcungqr generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pcungr2 generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th pcungrq generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of the index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of the index in the global array a that points to the start of the matrix to be operated on (which may be either all of note that for mycol > 0 one has lower triangular blocks! lm is the number of rows which is usually nb except fo is nr+bwu where nr is the number of columns on the last processor the index in the global array a that points to the start of the matrix to be operated on (which may be either all of 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 where sigma is an m-by-n matrix which is zero except for it v is an n-by-n orthogonal matrix. the diagonal elements of sigma 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 ictxt (global input) integer the blacs context handle in which the computation take or lower bidiagonal form by an orthogonal transformation q' * a * p, and returns the matrices x and y which are needed to apply th 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 pdlaebz contains the iteration loop which computes the eigenvalue j = 1,...,minp. it uses and computes the function n(w), which is iq (global input) integer q's global row index, which points to the beginning of th id (global input) integer q's global row/col index, which points to the beginnin sorted set. then it tries to deflate the size of the problem. there are two ways in which deflation can occur: when two or mor z vector. for each such occurrence the order of the related secular add/subtract, or on those binary machines without guard digits which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2 without guard digits, but we know of none. form z1 which consist of the last row of q 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 i1 and i2 are the indices of the first row and last column of h to which transformations must be applied. if eigenvalues only ar nal similarity transformation q' * a * q. the routine returns the matrices v and t which determine q as a block reflector i - v*t*v' ictxt (global input) integer the blacs context handle in which the computation take ia (global input) integer a's global row index, which points to the beginning o 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 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 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 pdlarft forms the triangular factor t of a real block reflector h of order n, which is defined as a product of k elementary reflectors if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular; 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 pdlarzt forms the triangular factor t of a real block reflector h of order > n, which is defined as a product of k elementar 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 form by an orthogonal similarity transformation q' * sub( a ) * q, and returns the matrices v and w which are needed to apply th 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 pdorg2l generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pdorg2r generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pdorgl2 generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pdorglq generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pdorgql generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pdorgqr generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pdorgr2 generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th pdorgrq generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of te 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 interval [vl, vu], or the eigenvalues indexed il through iu. a static partitioning of work is done at the beginning of pdstebz which eigenvalues. add/subtract, or on those binary machines without guard digits which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2 without guard digits, but we know of none. see dlaed3 for details. 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 a. rsrc_a (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the ia (global input) integer a's global row index, which points to the beginning of th 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 pdsyngst performs the same function as pdhegst, but is based on rank 2k updates, which are faster and more scalable tha pdsyntrd is a prototype version of pdsytrd which uses tailore when the workspace provided by the user is adequate. 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 distribute the columns of the array. rsrc_a (global) desca( rsrc_ ) the process row over which th 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 this version provides a set of parameters which should give good computers. users are encouraged to modify this subroutine to set 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of the index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of the index in the global array a that points to the start of the matrix to be operated on (which may be either all of note that for mycol > 0 one has lower triangular blocks! lm is the number of rows which is usually nb except fo is nr+bwu where nr is the number of columns on the last processor the index in the global array a that points to the start of the matrix to be operated on (which may be either all of 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 where sigma is an m-by-n matrix which is zero except for it v is an n-by-n orthogonal matrix. the diagonal elements of sigma 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 ictxt (global input) integer the blacs context handle in which the computation take or lower bidiagonal form by an orthogonal transformation q' * a * p, and returns the matrices x and y which are needed to apply th 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 pslaebz contains the iteration loop which computes the eigenvalue j = 1,...,minp. it uses and computes the function n(w), which is iq (global input) integer q's global row index, which points to the beginning of th id (global input) integer q's global row/col index, which points to the beginnin sorted set. then it tries to deflate the size of the problem. there are two ways in which deflation can occur: when two or mor z vector. for each such occurrence the order of the related secular add/subtract, or on those binary machines without guard digits which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2 without guard digits, but we know of none. form z1 which consist of the last row of q 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 i1 and i2 are the indices of the first row and last column of h to which transformations must be applied. if eigenvalues only ar nal similarity transformation q' * a * q. the routine returns the matrices v and t which determine q as a block reflector i - v*t*v' ictxt (global input) integer the blacs context handle in which the computation take ia (global input) integer a's global row index, which points to the beginning o 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 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 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 pslarft forms the triangular factor t of a real block reflector h of order n, which is defined as a product of k elementary reflectors if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular; 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 pslarzt forms the triangular factor t of a real block reflector h of order > n, which is defined as a product of k elementar 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 form by an orthogonal similarity transformation q' * sub( a ) * q, and returns the matrices v and w which are needed to apply th 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 psorg2l generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a psorg2r generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m psorgl2 generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a psorglq generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a psorgql generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a psorgqr generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m psorgr2 generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th psorgrq generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of te 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 interval [vl, vu], or the eigenvalues indexed il through iu. a static partitioning of work is done at the beginning of psstebz which eigenvalues. add/subtract, or on those binary machines without guard digits which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2 without guard digits, but we know of none. see slaed3 for details. 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 a. rsrc_a (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the ia (global input) integer a's global row index, which points to the beginning of th 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 pssyngst performs the same function as pshegst, but is based on rank 2k updates, which are faster and more scalable tha pssyntrd is a prototype version of pssytrd which uses tailore when the workspace provided by the user is adequate. 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 distribute the columns of the array. rsrc_a (global) desca( rsrc_ ) the process row over which th 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of te 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of the index in the global array a that points to the start of the matrix to be operated on (which may be either all of note that for mycol > 0 one has lower triangular blocks! lm is the number of rows which is usually nb except fo is nr+bwu where nr is the number of columns on the last processor the index in the global array a that points to the start of the matrix to be operated on (which may be either all of 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 where sigma is an m-by-n matrix which is zero except for it v is an n-by-n orthogonal matrix. the diagonal elements of sigma 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 a. rsrc_a (global) desca( rsrc_ ) the process row over which the firs csrc_a (global) desca( csrc_ ) the process column over which the ia (global input) integer a's global row index, which points to the beginning of th 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 pzhengst performs the same function as pzhegst, but is based on rank 2k updates, which are faster and more scalable tha pzhentrd is a prototype version of pzhetrd which uses tailore when the workspace provided by the user is adequate. 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 distribute the columns of the array. rsrc_a (global) desca( rsrc_ ) the process row over which th csrc_a (global) desca( csrc_ ) the process column over which the or lower bidiagonal form by an unitary transformation q' * a * p, and returns the matrices x and y which are needed to apply the transfor 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 i1 and i2 are the indices of the first row and last column of h to which transformations must be applied. if eigenvalues only ar performed by an unitary similarity transformation q' * a * q. the routine returns the matrices v and t which determine q as a bloc ia (global input) integer a's global row index, which points to the beginning o 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 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 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 pzlarft forms the triangular factor t of a complex block reflector h of order n, which is defined as a product of k elementary reflectors if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular; 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 pzlarzt forms the triangular factor t of a complex block reflector h of order > n, which is defined as a product of k elementar 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 tridiagonal form by an unitary similarity transformation q' * sub( a ) * q, and returns the matrices v and w which ar 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of 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 index in the global array a that points to the start of the matrix to be operated on (which may be either all of transfer last triangle d_i of local matrix to next processor which needs it to calculate fillin due to factorization o overlap the send with the factorization of a_i. the index in the global array a that points to the start of the matrix to be operated on (which may be either all of 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 pzung2l generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pzung2r generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pzungl2 generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pzunglq generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pzungql generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pzungqr generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pzungr2 generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th pzungrq generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th 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 here a11, a21 and a31 denote the current block of jb columns which is about to be factorized. the number of rows in th of columns are jb, j2, j3. the superdiagonal elements of a13 here a11, a21 and a31 denote the current block of jb columns which is about to be factorized. the number of rows in th of columns are jb, j2, j3. the superdiagonal elements of a13 i1 and i2 are the indices of the first row and last column of h to which transformations must be applied. if eigenvalues only ar |
| while while the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other however, because there are many bulges, k1(ki) & k2(ki) might go past that range while later bulges (ki+1,ki+2,etc..) ar communication sometimes k1(ki)=hbl-2 & k2(ki)=hbl-1 so both icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums while irsr0 : pointer to part of work used to store the rowsums after icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums while irsr0 : pointer to part of work used to store the rowsums after the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other performance. the diagonal entries of t are in the entries d(1),d(3),...,d(2*n-1), while the squares of the off-diagona matrix must be scaled so that its largest entry is no greater > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while working on the submatrix lying i however, because there are many bulges, k1(ki) & k2(ki) might go past that range while later bulges (ki+1,ki+2,etc..) ar icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums while irsr0 : pointer to part of work used to store the rowsums after performance. the diagonal entries of t are in the entries d(1),d(3),...,d(2*n-1), while the squares of the off-diagona matrix must be scaled so that its largest entry is no greater the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while working on the submatrix lying i > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while working on the submatrix lying i the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other performance. the diagonal entries of t are in the entries d(1),d(3),...,d(2*n-1), while the squares of the off-diagona matrix must be scaled so that its largest entry is no greater > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while working on the submatrix lying i however, because there are many bulges, k1(ki) & k2(ki) might go past that range while later bulges (ki+1,ki+2,etc..) ar icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums while irsr0 : pointer to part of work used to store the rowsums after performance. the diagonal entries of t are in the entries d(1),d(3),...,d(2*n-1), while the squares of the off-diagona matrix must be scaled so that its largest entry is no greater the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while working on the submatrix lying i > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while working on the submatrix lying i the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other however, because there are many bulges, k1(ki) & k2(ki) might go past that range while later bulges (ki+1,ki+2,etc..) ar communication sometimes k1(ki)=hbl-2 & k2(ki)=hbl-1 so both icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums while irsr0 : pointer to part of work used to store the rowsums after icurcol : process column containing diagonal block irsc0 : pointer to part of work used to store the rowsums while irsr0 : pointer to part of work used to store the rowsums after the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors the following are restrictions on the input parameters. some of these are temporary and will be removed in future releases, while other calculate new ja one while dropping off unused processors |
| who who get first transform on node who owns m+2,m+ get first transform on node who owns m+2,m+ get first transform on node who owns m+2,m+ get first transform on node who owns m+2,m+ |
| whole whole copy diagonal block to align whole syste copy diagonal block to align whole syste copy diagonal block to align whole syste copy diagonal block to align whole syste |
| whose whose to an array of dimension ( lld_a, locc(ja+n-1) ), the local pieces of the m-by-n distributed matrix whose dimension (nprow*npcol) this array contains the gap between eigenvalues whose values in this array correspond to the clusters indicated dimension (nprow*npcol) this array contains the gap between eigenvalues whose values in this array correspond to the clusters indicated (desca(lld_),*) on entry, the hessenberg matrix whose tridiagonal part i unchanged on exit. the order of the matrix t (= the number of elementary reflectors whose product defines the block reflector) v (local input) complex pointer into the local memory the order of the matrix t (= the number of elementary reflectors whose product defines the block reflector) l (global input) integer a (global input) complex array, dimension (desca(lld_),*) on entry, the hessenberg matrix whose tridiagonal part i unchanged on exit. the factorization is obtained by householder's method. the kth transformation matrix, z( k ), whose conjugate transpose is used t the form the global index of the element of the distributed vector sub( x ) whose real part has maximum absolute value x (local input) complex array containing the local n-by-n hermitian positive definite distributed matrix sub( a ) whose scaling factors are to be computed. only th gap (global output) real array, dimension (p) this output array contains the gap between eigenvalues whose values in this array correspond to the info/(m+1) clusters the factorization is obtained by householder's method. the kth transformation matrix, z( k ), whose conjugate transpose is used t the form k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. if side = 'l', and nq = n otherwise. the vectors which define the elementary reflectors h(i) and g(i), whose pcgebrd. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. to an array of dimension ( lld_a, locc(ja+n-1) ), the local pieces of the m-by-n distributed matrix whose (desca(lld_),*) on entry, the hessenberg matrix whose tridiagonal part i unchanged on exit. byall(i) = bycol( numroc(i,desc( nb_ ),myrow,0,nprow ) on the procs whose myrow == mod((i-1)/desc( nb_ ),nprow work (local workspace) double precision dimension (lwork) byall(i) = byrow( numroc(i,desc( mb_ ),mycol,0,npcol ) on the procs whose mycol == mod((i-1)/desc( mb_ ),npcol work (local workspace) double precision dimension (lwork) the order of the matrix t (= the number of elementary reflectors whose product defines the block reflector) v (local input) double precision pointer into the local memory the order of the matrix t (= the number of elementary reflectors whose product defines the block reflector) l (global input) integer (desca(lld_),*) on entry, the hessenberg matrix whose tridiagonal part i unchanged on exit. k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. if side = 'l', and nq = n otherwise. the vectors which define the elementary reflectors h(i) and g(i), whose pdgebrd. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. n-by-n symmetric positive definite distributed matrix sub( a ) whose scaling factors are to be computed. only th (or cluster) is considered to be located if it has been determined to lie in an interval whose width is abstol o will be used, where |t| means the 1-norm of t. gap (global output) double precision array, dimension (p) this output array contains the gap between eigenvalues whose values in this array correspond to the info/(m+1) clusters dimension (nprow*npcol) this array contains the gap between eigenvalues whose values in this array correspond to the clusters indicated dimension (nprow*npcol) this array contains the gap between eigenvalues whose values in this array correspond to the clusters indicated to an array of dimension ( lld_a, locc(ja+n-1) ), the local pieces of the m-by-n distributed matrix whose (desca(lld_),*) on entry, the hessenberg matrix whose tridiagonal part i unchanged on exit. byall(i) = bycol( numroc(i,desc( nb_ ),myrow,0,nprow ) on the procs whose myrow == mod((i-1)/desc( nb_ ),nprow work (local workspace) real dimension (lwork) byall(i) = byrow( numroc(i,desc( mb_ ),mycol,0,npcol ) on the procs whose mycol == mod((i-1)/desc( mb_ ),npcol work (local workspace) real dimension (lwork) the order of the matrix t (= the number of elementary reflectors whose product defines the block reflector) v (local input) real pointer into the local memory the order of the matrix t (= the number of elementary reflectors whose product defines the block reflector) l (global input) integer (desca(lld_),*) on entry, the hessenberg matrix whose tridiagonal part i unchanged on exit. k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. if side = 'l', and nq = n otherwise. the vectors which define the elementary reflectors h(i) and g(i), whose psgebrd. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. n-by-n symmetric positive definite distributed matrix sub( a ) whose scaling factors are to be computed. only th (or cluster) is considered to be located if it has been determined to lie in an interval whose width is abstol o will be used, where |t| means the 1-norm of t. gap (global output) real array, dimension (p) this output array contains the gap between eigenvalues whose values in this array correspond to the info/(m+1) clusters dimension (nprow*npcol) this array contains the gap between eigenvalues whose values in this array correspond to the clusters indicated dimension (nprow*npcol) this array contains the gap between eigenvalues whose values in this array correspond to the clusters indicated to an array of dimension ( lld_a, locc(ja+n-1) ), the local pieces of the m-by-n distributed matrix whose dimension (nprow*npcol) this array contains the gap between eigenvalues whose values in this array correspond to the clusters indicated dimension (nprow*npcol) this array contains the gap between eigenvalues whose values in this array correspond to the clusters indicated (desca(lld_),*) on entry, the hessenberg matrix whose tridiagonal part i unchanged on exit. the order of the matrix t (= the number of elementary reflectors whose product defines the block reflector) v (local input) complex*16 pointer into the local memory the order of the matrix t (= the number of elementary reflectors whose product defines the block reflector) l (global input) integer a (global input) complex*16 array, dimension (desca(lld_),*) on entry, the hessenberg matrix whose tridiagonal part i unchanged on exit. the factorization is obtained by householder's method. the kth transformation matrix, z( k ), whose conjugate transpose is used t the form the global index of the element of the distributed vector sub( x ) whose real part has maximum absolute value x (local input) complex*16 array containing the local n-by-n hermitian positive definite distributed matrix sub( a ) whose scaling factors are to be computed. only th gap (global output) double precision array, dimension (p) this output array contains the gap between eigenvalues whose values in this array correspond to the info/(m+1) clusters the factorization is obtained by householder's method. the kth transformation matrix, z( k ), whose conjugate transpose is used t the form k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. if side = 'l', and nq = n otherwise. the vectors which define the elementary reflectors h(i) and g(i), whose pzgebrd. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. k (global input) integer the number of elementary reflectors whose product defines th n >= k >= 0. |
| widen widen fudge double precision, default = 2.0 a "fudge factor" to widen the gershgorin intervals. ideally arithmetic, this needs to be larger. the default for fudge real, default = 2.0 a "fudge factor" to widen the gershgorin intervals. ideally arithmetic, this needs to be larger. the default for |
| width width when it is determined to lie in an interval [a,b] of width less than or equal t abstol + eps * max( |a|,|b| ) , when it is determined to lie in an interval [a,b] of width less than or equal t abstol + eps * max( |a|,|b| ) , abstol (input) double precision the minimum (absolute) width of an interval. when an interva magnitude) endpoint, then it is considered to be sufficiently abstol (input) double precision the minimum (absolute) width of an interval. when an interva magnitude) endpoint, then it is considered to be sufficiently (or cluster) is considered to be located if it has been determined to lie in an interval whose width is abstol o will be used, where |t| means the 1-norm of t. when it is determined to lie in an interval [a,b] of width less than or equal t abstol + eps * max( |a|,|b| ) , when it is determined to lie in an interval [a,b] of width less than or equal t abstol + eps * max( |a|,|b| ) , abstol (input) real the minimum (absolute) width of an interval. when an interva magnitude) endpoint, then it is considered to be sufficiently abstol (input) real the minimum (absolute) width of an interval. when an interva magnitude) endpoint, then it is considered to be sufficiently (or cluster) is considered to be located if it has been determined to lie in an interval whose width is abstol o will be used, where |t| means the 1-norm of t. when it is determined to lie in an interval [a,b] of width less than or equal t abstol + eps * max( |a|,|b| ) , when it is determined to lie in an interval [a,b] of width less than or equal t abstol + eps * max( |a|,|b| ) , when it is determined to lie in an interval [a,b] of width less than or equal t abstol + eps * max( |a|,|b| ) , when it is determined to lie in an interval [a,b] of width less than or equal t abstol + eps * max( |a|,|b| ) , |
| Wilkinson Wilkinson prepare to use Wilkinson's shift copy submatrix of size 2*jblk and prepare to do generalized Wilkinson shift or an exceptional shif copy submatrix of size 2*jblk and prepare to do generalized Wilkinson shift or an exceptional shif copy submatrix of size 2*jblk and prepare to do generalized Wilkinson shift or an exceptional shif copy submatrix of size 2*jblk and prepare to do generalized Wilkinson shift or an exceptional shif prepare to use Wilkinson's shift |
| will will 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 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) move block into place that it will be expected to be fo nb*(bwl+bwu)+6*max(bwl,bwu)*max(bwl,bwu) if laf is not large enough, an error code will be returne size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol+3*nb) move block into place that it will be expected to be fo 2*(nb+2) if laf is not large enough, an error code will be returne 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) in this case the loop over the levels will not b (nb+bwu)*(bwl+bwu)+6*(bwl+bwu)*(bwl+2*bwu) if laf is not large enough, an error code will be returne trans = 'c': (diag(r)*a*diag(c))**h *inv(diag(r))*x = diag(c)*b whether or not the system will be equilibrated depends on th overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n') 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 range (global input) character*1 = 'a': all eigenvalues will be found = 'i': the il-th through iu-th eigenvalues will be found. range (global input) character*1 = 'a': all eigenvalues will be found = 'i': the il-th through iu-th eigenvalues will be found. pchettrd is not intended to be called directly. all users are encourage to call pchetrd which will then call pchettrd i the process grid must be square ( i.e. nprow = npcol ) and on the initial call to pclacon, kase should be 0. on an intermediate return, kase will be 1 or 2, indicatin on the final return from pclacon, kase will again be 0. on exit, this yields the starting location of the qr double shift. this will satisfy: l <= m <= i-2 h44 nbulge is the number of bulges that will be attempte or a column. the pivot vector should be aligned with the distributed matrix a. this routine will transpose the pivot vector if necessary sub( a ), pass rowcol='c' and pivroc='c'. specifies if the rows or columns are to be permuted: = 'r' rows will be permuted 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 satisf 1.0 .le. ssq .le. ( sumsq + 2*n ). already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pclapiv. when the result of a vector-oriented pblas call is a scalar, it will being operated on. let x be a generic term for the input vector(s). size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (nb+2*bw)*bw move block into place that it will be expected to be fo (nb+2*bw)*bw if laf is not large enough, an error code will be returne diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b whether or not the system will be equilibrated depends on th overwritten by diag(sr)*a*diag(sc) and b by diag(sr)*b. size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol + 3*nb) move block into place that it will be expected to be fo (nb+2) if laf is not large enough, an error code will be returne the scalar a which is used to divide each component of sub( x ). sa must be >= 0, or the subroutine will divide b orthogonalized can be stored in one process. no orthogonalization will be done if orfac equals zero orfac should be identical on all processes. 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) nb*(bwl+bwu)+6*max(bwl,bwu)*max(bwl,bwu) if laf is not large enough, an error code will be returne size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol+3*nb) move block into place that it will be expected to be fo 2*(nb+2) if laf is not large enough, an error code will be returne 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) in this case the loop over the levels will not b (nb+bwu)*(bwl+bwu)+6*(bwl+bwu)*(bwl+2*bwu) if laf is not large enough, an error code will be returne trans = 'c': (diag(r)*a*diag(c))**h *inv(diag(r))*x = diag(c)*b whether or not the system will be equilibrated depends on th overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n') 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 on the initial call to pdlacon, kase should be 0. on an intermediate return, kase will be 1 or 2, indicatin on the final return from pdlacon, kase will again be 0. on exit, this yields the starting location of the qr double shift. this will satisfy: l <= m <= i-2 h44 the maximum number of intervals that may be generated. if more than mmax intervals are generated, then pdlaebz will oendpoint f the j-th interval, and intvl(2*j) is the right endpoint of the j-th interval. the input intervals will on input, intvl contains the kl-kf input intervals. dlamda (global output) double precision array, dimension (n) a copy of the first k eigenvalues which will be used b this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. nbulge is the number of bulges that will be attempte the innermost loop to avoid overflow and determine the sign of a floating point number. pdlapdct will be referred to as the "paranoid or a column. the pivot vector should be aligned with the distributed matrix a. this routine will transpose the pivot vector if necessary sub( a ), pass rowcol='c' and pivroc='c'. specifies if the rows or columns are to be permuted: = 'r' rows will be permuted rows and that all process columns contain the same copy of bycol. the output array, byall, will be identical on all processe columns and that all process rows contain the same copy of byrow. the output array, byall, will be identical on all processe on exit, this yields the bottom portion of the unreduced submatrix. this will satisfy: l <= m <= i-1 smlnum (global input) double precision already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pdlapiv. size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (nb+2*bw)*bw move block into place that it will be expected to be fo (nb+2*bw)*bw if laf is not large enough, an error code will be returne diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b whether or not the system will be equilibrated depends on th overwritten by diag(sr)*a*diag(sc) and b by diag(sr)*b. size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol + 3*nb) move block into place that it will be expected to be fo (nb+2) if laf is not large enough, an error code will be returne the scalar a which is used to divide each component of sub( x ). sa must be >= 0, or the subroutine will divide b specifies which eigenvalues are to be found.
= 'a': ("all") all eigenvalues will be found
[vl, vu] will be found.
this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. orthogonalized can be stored in one process. no orthogonalization will be done if orfac equals zero orfac should be identical on all processes. range (global input) character*1 = 'a': all eigenvalues will be found = 'i': the il-th through iu-th eigenvalues will be found. range (global input) character*1 = 'a': all eigenvalues will be found = 'i': the il-th through iu-th eigenvalues will be found. pdsyttrd is not intended to be called directly. all users are encourage to call pdsytrd which will then call pdhettrd i the process grid must be square ( i.e. nprow = npcol ) and when the result of a vector-oriented pblas call is a scalar, it will being operated on. let x be a generic term for the input vector(s). this routine will not function correctly if it is converted to al when the result of a vector-oriented pblas call is a scalar, it will being operated on. let x be a generic term for the input vector(s). 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) nb*(bwl+bwu)+6*max(bwl,bwu)*max(bwl,bwu) if laf is not large enough, an error code will be returne size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol+3*nb) move block into place that it will be expected to be fo 2*(nb+2) if laf is not large enough, an error code will be returne 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) in this case the loop over the levels will not b (nb+bwu)*(bwl+bwu)+6*(bwl+bwu)*(bwl+2*bwu) if laf is not large enough, an error code will be returne trans = 'c': (diag(r)*a*diag(c))**h *inv(diag(r))*x = diag(c)*b whether or not the system will be equilibrated depends on th overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n') 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 on the initial call to pslacon, kase should be 0. on an intermediate return, kase will be 1 or 2, indicatin on the final return from pslacon, kase will again be 0. on exit, this yields the starting location of the qr double shift. this will satisfy: l <= m <= i-2 h44 the maximum number of intervals that may be generated. if more than mmax intervals are generated, then pslaebz will oendpoint f the j-th interval, and intvl(2*j) is the right endpoint of the j-th interval. the input intervals will on input, intvl contains the kl-kf input intervals. dlamda (global output) real array, dimension (n) a copy of the first k eigenvalues which will be used b this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. nbulge is the number of bulges that will be attempte the innermost loop to avoid overflow and determine the sign of a floating point number. pslapdct will be referred to as the "paranoid or a column. the pivot vector should be aligned with the distributed matrix a. this routine will transpose the pivot vector if necessary sub( a ), pass rowcol='c' and pivroc='c'. specifies if the rows or columns are to be permuted: = 'r' rows will be permuted rows and that all process columns contain the same copy of bycol. the output array, byall, will be identical on all processe columns and that all process rows contain the same copy of byrow. the output array, byall, will be identical on all processe on exit, this yields the bottom portion of the unreduced submatrix. this will satisfy: l <= m <= i-1 smlnum (global input) real already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pslapiv. size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (nb+2*bw)*bw move block into place that it will be expected to be fo (nb+2*bw)*bw if laf is not large enough, an error code will be returne diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b whether or not the system will be equilibrated depends on th overwritten by diag(sr)*a*diag(sc) and b by diag(sr)*b. size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol + 3*nb) move block into place that it will be expected to be fo (nb+2) if laf is not large enough, an error code will be returne the scalar a which is used to divide each component of sub( x ). sa must be >= 0, or the subroutine will divide b specifies which eigenvalues are to be found.
= 'a': ("all") all eigenvalues will be found
[vl, vu] will be found.
this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. orthogonalized can be stored in one process. no orthogonalization will be done if orfac equals zero orfac should be identical on all processes. range (global input) character*1 = 'a': all eigenvalues will be found = 'i': the il-th through iu-th eigenvalues will be found. range (global input) character*1 = 'a': all eigenvalues will be found = 'i': the il-th through iu-th eigenvalues will be found. pssyttrd is not intended to be called directly. all users are encourage to call pssytrd which will then call pshettrd i the process grid must be square ( i.e. nprow = npcol ) and 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) move block into place that it will be expected to be fo nb*(bwl+bwu)+6*max(bwl,bwu)*max(bwl,bwu) if laf is not large enough, an error code will be returne the scalar a which is used to divide each component of sub( x ). sa must be >= 0, or the subroutine will divide b size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol+3*nb) move block into place that it will be expected to be fo 2*(nb+2) if laf is not large enough, an error code will be returne 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) in this case the loop over the levels will not b (nb+bwu)*(bwl+bwu)+6*(bwl+bwu)*(bwl+2*bwu) if laf is not large enough, an error code will be returne trans = 'c': (diag(r)*a*diag(c))**h *inv(diag(r))*x = diag(c)*b whether or not the system will be equilibrated depends on th overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n') 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 range (global input) character*1 = 'a': all eigenvalues will be found = 'i': the il-th through iu-th eigenvalues will be found. range (global input) character*1 = 'a': all eigenvalues will be found = 'i': the il-th through iu-th eigenvalues will be found. pzhettrd is not intended to be called directly. all users are encourage to call pzhetrd which will then call pzhettrd i the process grid must be square ( i.e. nprow = npcol ) and on the initial call to pzlacon, kase should be 0. on an intermediate return, kase will be 1 or 2, indicatin on the final return from pzlacon, kase will again be 0. on exit, this yields the starting location of the qr double shift. this will satisfy: l <= m <= i-2 h44 nbulge is the number of bulges that will be attempte or a column. the pivot vector should be aligned with the distributed matrix a. this routine will transpose the pivot vector if necessary sub( a ), pass rowcol='c' and pivroc='c'. specifies if the rows or columns are to be permuted: = 'r' rows will be permuted 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 satisf 1.0 .le. ssq .le. ( sumsq + 2*n ). already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pzlapiv. when the result of a vector-oriented pblas call is a scalar, it will being operated on. let x be a generic term for the input vector(s). size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (nb+2*bw)*bw move block into place that it will be expected to be fo (nb+2*bw)*bw if laf is not large enough, an error code will be returne diag(sr) * a * diag(sc) * inv(diag(sc)) * x = diag(sr) * b whether or not the system will be equilibrated depends on th overwritten by diag(sr)*a*diag(sc) and b by diag(sr)*b. size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol + 3*nb) move block into place that it will be expected to be fo (nb+2) if laf is not large enough, an error code will be returne orthogonalized can be stored in one process. no orthogonalization will be done if orfac equals zero orfac should be identical on all processes. 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 |
| wing wing such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a such a global array has an associated description vector desca. in the following comments, the character _ should be read a |
| wise wise biggest boost in performance comes for small n, so it is wise to provide the extra workspace (typically les biggest boost in performance comes for small n, so it is wise to provide the extra workspace (typically les biggest boost in performance comes for small n, so it is wise to provide the extra workspace (typically les biggest boost in performance comes for small n, so it is wise to provide the extra workspace (typically les |
| with with cdbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. cdttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form u * x = b, u**t * x = b, or u**h * x = b, with factors of the tridiagonal matrix a from the lu factorizatio 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. t - complex array of dimension ( ldt, n ). before entry with uplo = 'u' or 'u', the leading n by triangular matrix and the strictly lower triangular part of ddbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. ddttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form u * x = b, u**t * x = b, or u**h * x = b, with factors of the tridiagonal matrix a from the lu factorizatio compute lu factors with partial pivoting ( pt = lu t - double precision array of dimension ( ldt, n ). before entry with uplo = 'u' or 'u', the leading n by triangular matrix and the strictly lower triangular part of banded diagonally dominant-like distributed matrix with bandwidth bwl, bwu gaussian elimination without pivoting want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded diagonally dominant-like distributed matrix with bandwidth bwl, bwu routine pcdbtrf must be called first. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. gaussian elimination without pivotin of the matrix into l u. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. trans (global input) character = 'n': solve with a(1:n, ja:ja+n-1) want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded distributed matrix with bandwidth bwl, bwu gaussian elimination with pivoting want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded distributed matrix with bandwidth bwl, bwu routine pcgbtrf must be called first. the diagonal and the first superdiagonal of sub( a ) are overwritten with the upper bidiagonal matrix b; the element unitary matrix q as a product of elementary reflectors, and the diagonal and the first superdiagonal of sub( a ) are overwritten with the upper bidiagonal matrix b; the element unitary matrix q as a product of elementary reflectors, and the column scale factors, chosen to try to make the largest entry in each row and column of the distributed matrix b with element the upper triangle and the first subdiagonal of sub( a ) are overwritten with the upper hessenberg matrix h, and the ele sent the unitary matrix q as a product of elementary the upper triangle and the first subdiagonal of sub( a ) are overwritten with the upper hessenberg matrix h, and the ele sent the unitary matrix q as a product of elementary lower trapezoidal matrix l (l is lower triangular if m <= n); the elements above the diagonal, with the array tau, repre reflectors (see further details). lower trapezoidal matrix l (l is lower triangular if m <= n); the elements above the diagonal, with the array tau, repre reflectors (see further details). where lcmp = lcm / nprow with lcm = ilcm( nprow, npcol ) iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), the (n-m)-th superdiagonal contain the m by n lower trapezoidal matrix l; the remaining elements, with th elementary reflectors (see further details). the (n-m)-th superdiagonal contain the m by n lower trapezoidal matrix l; the remaining elements, with th elementary reflectors (see further details). pcgeqpf computes a qr factorization with column pivoting of upper trapezoidal matrix r (r is upper triangular if m >= n); the elements below the diagonal, with the array tau reflectors (see further details). upper trapezoidal matrix r (r is upper triangular if m >= n); the elements below the diagonal, with the array tau reflectors (see further details). by pcgetrf. ipiv(i) -> the global row local row i was swapped with. this array is tied to the distribute and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). the lu decomposition with partial pivoting and row interchanges i tation matrix, l is unit lower triangular, and u is upper triangular. if equed is not 'n', the matrix a(ia:ia+n-1,ja:ja+n-1) has been equilibrated with a(ia:ia+n-1,ja:ja+n-1), af(iaf:iaf+n-1,jaf:jaf+n-1), distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using partial pivoting with row interchanges the factorization has the form sub( a ) = p * l * u, where p is a 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 with keeps track of the pivoting information. ipiv(i) is the global row index the local row i was swapped with. thi with a general n-by-n distributed matrix sub( a ) using the l sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a, a**t or a**h upper trapezoidal matrix r (r is upper triangular if n >= m); the elements below the diagonal, with the array taua elementary reflectors (see further details). and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro lwork = n + ( np0 + mq0 + nb ) * nb, with np0 = numroc( max( n, nb, 2 ), nb, 0, 0, nprow set to twice the underflow threshold 2*pslamch('s') not zero.
if this routine returns with ((mod(info,2).ne.0) .or
eigenvectors did not converge, try setting abstol to
set to twice the underflow threshold 2*pslamch('s') not zero.
if this routine returns with ((mod(info,2).ne.0) .or
eigenvectors did not converge, try setting abstol to
matrix t, and the elements above the first superdiagonal, with the array tau, represent the unitary matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the unitary matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the unitary matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the unitary matrix q as and first subdiagonal of sub( a ) are overwritten by the if m >= n, elements on and below the diagonal in the first nb columns, with the array tauq, represent the unitar elements above the diagonal in the first nb rows, with the a. reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, thi the eigenvectors on output. the eigenvectors are distributed in a block cyclic manner in both dimensions, with 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 k-th subdiagonal in the first nb columns are overwritten with the corresponding elements of the reduced distribute array tau, represent the matrix q as a product of elementary to 1. indeed, i suspect that ib should always be set to 1 or ignored with 1 used in its place pclamr1d has not been tested except withint the contect of ( max(abs(a(i,j))), norm = 'm' or 'm' with ia <= i <= ia+m-1 ( 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, 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. the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligned with the distributed matrix a, and replicated across ever where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), before entry, the incremented array sub( x ) must contain the vector x. on exit, it is overwritten with the vector v ix (global input) integer the k-by-k triangular factor of the block reflector asso- ciated with v. if direct = 'f', t is upper triangular where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), it contains the k-by-k triangular factor of the block reflector associated with v. t is lower triangular work (local workspace) complex array, on entry, the value scale in the equation above. on exit, scale is overwritten with scl , the scaling facto on exit, if uplo = 'u', the last nb columns have been reduced to tridiagonal form, with the diagonal elements overwritin diagonal with the array tau, represent the unitary matrix q gular matrix r, and elements n-l+1 to n of the first m rows of sub( a ), with the array tau, represent the unitary matri on exit, if uplo = 'u', the upper triangle of the distributed matrix sub( a ) is overwritten with the upper triangle of th is overwritten with the lower triangle of the product l' * l. on exit, if uplo = 'u', the upper triangle of the distributed matrix sub( a ) is overwritten with the upper triangle of th is overwritten with the lower triangle of the product l' * l. 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 banded symmetric positive definite distributed matrix with bandwidth bw cholesky factorization is used to factor a reordering of want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded symmetric positive definite distributed matrix with bandwidth bw a(1:n, ja:ja+n-1) = u'*u or l*l' as computed by pcpbtrf. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. 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 scal buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones on ted matrix sub( b ). on exit, if info = 0, sub( b ) is over- written with the solution distributed matrix x ib (global input) integer if equed = 'y', the matrix a has been equilibrated with scaling factors given by s. a and af will no = 'n': the matrix a will be copied to af and factored. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. 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. pctrrfs provides error bounds and backward error estimates for the solution to a system of linear equations with a triangula gular matrix r, and elements m+1 to n of the first m rows of sub( a ), with the array tau, represent the unitary matrix pcung2l generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pcung2r generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pcungl2 generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pcunglq generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pcungql generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pcungqr generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pcungr2 generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th pcungrq generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th pcunm2l overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with side = 'l' side = 'r' banded diagonally dominant-like distributed matrix with bandwidth bwl, bwu gaussian elimination without pivoting want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded diagonally dominant-like distributed matrix with bandwidth bwl, bwu routine pddbtrf must be called first. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. gaussian elimination without pivotin of the matrix into l u. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. trans (global input) character = 'n': solve with a(1:n, ja:ja+n-1) want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded distributed matrix with bandwidth bwl, bwu gaussian elimination with pivoting want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded distributed matrix with bandwidth bwl, bwu routine pdgbtrf must be called first. the diagonal and the first superdiagonal of sub( a ) are overwritten with the upper bidiagonal matrix b; the element orthogonal matrix q as a product of elementary reflectors, the diagonal and the first superdiagonal of sub( a ) are overwritten with the upper bidiagonal matrix b; the element orthogonal matrix q as a product of elementary reflectors, the column scale factors, chosen to try to make the largest entry in each row and column of the distributed matrix b with element the upper triangle and the first subdiagonal of sub( a ) are overwritten with the upper hessenberg matrix h, and the ele sent the orthogonal matrix q as a product of elementary the upper triangle and the first subdiagonal of sub( a ) are overwritten with the upper hessenberg matrix h, and the ele sent the orthogonal matrix q as a product of elementary lower trapezoidal matrix l (l is lower triangular if m <= n); the elements above the diagonal, with the array tau, repre reflectors (see further details). lower trapezoidal matrix l (l is lower triangular if m <= n); the elements above the diagonal, with the array tau, repre reflectors (see further details). where lcmp = lcm / nprow with lcm = ilcm( nprow, npcol ) iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), the (n-m)-th superdiagonal contain the m by n lower trapezoidal matrix l; the remaining elements, with th elementary reflectors (see further details). the (n-m)-th superdiagonal contain the m by n lower trapezoidal matrix l; the remaining elements, with th elementary reflectors (see further details). pdgeqpf computes a qr factorization with column pivoting of upper trapezoidal matrix r (r is upper triangular if m >= n); the elements below the diagonal, with the array tau reflectors (see further details). upper trapezoidal matrix r (r is upper triangular if m >= n); the elements below the diagonal, with the array tau reflectors (see further details). by pdgetrf. ipiv(i) -> the global row local row i was swapped with. this array is tied to the distribute and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). the lu decomposition with partial pivoting and row interchanges i tation matrix, l is unit lower triangular, and u is upper triangular. if equed is not 'n', the matrix a(ia:ia+n-1,ja:ja+n-1) has been equilibrated with a(ia:ia+n-1,ja:ja+n-1), af(iaf:iaf+n-1,jaf:jaf+n-1), distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using partial pivoting with row interchanges the factorization has the form sub( a ) = p * l * u, where p is a 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 with keeps track of the pivoting information. ipiv(i) is the global row index the local row i was swapped with. thi with a general n-by-n distributed matrix sub( a ) using the l sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a or a**t and upper trapezoidal matrix r (r is upper triangular if n >= m); the elements below the diagonal, with the array taua elementary reflectors (see further details). and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). 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 if m >= n, elements on and below the diagonal in the first nb columns, with the array tauq, represent the orthogona elements above the diagonal in the first nb rows, with the reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, this informatio specifies the computation done by pdlaebz = 0 : find an interval with desired values of n(w) at th = 1 : find a floating point number contained in the initial work (local workspace ) double precision array, dimension (lwork) lwork = 6*n + 2*np*nq, with nq = numroc( n, nb_q, mycol, iqcol, npcol ) where z = q'u, u is a vector of length n with ones in th 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 this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. the eigenvectors on output. the eigenvectors are distributed in a block cyclic manner in both dimensions, with 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 k-th subdiagonal in the first nb columns are overwritten with the corresponding elements of the reduced distribute array tau, represent the matrix q as a product of elementary to 1. indeed, i suspect that ib should always be set to 1 or ignored with 1 used in its place pdlamr1d has not been tested except withint the contect of ( max(abs(a(i,j))), norm = 'm' or 'm' with ia <= i <= ia+m-1 ( 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, 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. the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligned with the distributed matrix a, and replicated across ever where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), before entry, the incremented array sub( x ) must contain the vector x. on exit, it is overwritten with the vector v ix (global input) integer the k-by-k triangular factor of the block reflector asso- ciated with v. if direct = 'f', t is upper triangular where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), it contains the k-by-k triangular factor of the block reflector associated with v. t is lower triangular work (local workspace) double precision array, on entry, the value scale in the equation above. on exit, scale is overwritten with scl , the scaling facto on exit, if uplo = 'u', the last nb columns have been reduced to tridiagonal form, with the diagonal elements overwritin diagonal with the array tau, represent the orthogonal matrix gular matrix r, and elements n-l+1 to n of the first m rows of sub( a ), with the array tau, represent the orthogona on exit, if uplo = 'u', the upper triangle of the distributed matrix sub( a ) is overwritten with the upper triangle of th is overwritten with the lower triangle of the product l' * l. on exit, if uplo = 'u', the upper triangle of the distributed matrix sub( a ) is overwritten with the upper triangle of th is overwritten with the lower triangle of the product l' * l. pdorg2l generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pdorg2r generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pdorgl2 generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pdorglq generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pdorgql generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pdorgqr generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pdorgr2 generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th pdorgrq generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th pdorm2l overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with side = 'l' side = 'r' banded symmetric positive definite distributed matrix with bandwidth bw cholesky factorization is used to factor a reordering of want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded symmetric positive definite distributed matrix with bandwidth bw a(1:n, ja:ja+n-1) = u'*u or l*l' as computed by pdpbtrf. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. 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 scal buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones on ted matrix sub( b ). on exit, if info = 0, sub( b ) is over- written with the solution distributed matrix x ib (global input) integer if equed = 'y', the matrix a has been equilibrated with scaling factors given by s. a and af will no = 'n': the matrix a will be copied to af and factored. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. split-off block (see iblock, isplit) and
ordered from smallest to largest withi
= 'e': ("entire matrix")
this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. 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. the different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro the different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro set to twice the underflow threshold 2*pdlamch('s') not zero.
if this routine returns with ((mod(info,2).ne.0) .or
eigenvectors did not converge, try setting abstol to
set to twice the underflow threshold 2*pdlamch('s') not zero.
if this routine returns with ((mod(info,2).ne.0) .or
eigenvectors did not converge, try setting abstol to
matrix t, and the elements above the first superdiagonal, with the array tau, represent the orthogonal matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the orthogonal matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the orthogonal matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the unitary matrix q as and first subdiagonal of sub( a ) are overwritten by the pdtrrfs provides error bounds and backward error estimates for the solution to a system of linear equations with a triangula gular matrix r, and elements m+1 to n of the first m rows of sub( a ), with the array tau, represent the orthogonal matri the serial version of this routine was originally contributed by nick higham for use with zlacon notes the serial version of this routine was originally contributed by nick higham for use with clacon notes banded diagonally dominant-like distributed matrix with bandwidth bwl, bwu gaussian elimination without pivoting want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded diagonally dominant-like distributed matrix with bandwidth bwl, bwu routine psdbtrf must be called first. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. gaussian elimination without pivotin of the matrix into l u. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. trans (global input) character = 'n': solve with a(1:n, ja:ja+n-1) want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded distributed matrix with bandwidth bwl, bwu gaussian elimination with pivoting want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded distributed matrix with bandwidth bwl, bwu routine psgbtrf must be called first. the diagonal and the first superdiagonal of sub( a ) are overwritten with the upper bidiagonal matrix b; the element orthogonal matrix q as a product of elementary reflectors, the diagonal and the first superdiagonal of sub( a ) are overwritten with the upper bidiagonal matrix b; the element orthogonal matrix q as a product of elementary reflectors, the column scale factors, chosen to try to make the largest entry in each row and column of the distributed matrix b with element the upper triangle and the first subdiagonal of sub( a ) are overwritten with the upper hessenberg matrix h, and the ele sent the orthogonal matrix q as a product of elementary the upper triangle and the first subdiagonal of sub( a ) are overwritten with the upper hessenberg matrix h, and the ele sent the orthogonal matrix q as a product of elementary lower trapezoidal matrix l (l is lower triangular if m <= n); the elements above the diagonal, with the array tau, repre reflectors (see further details). lower trapezoidal matrix l (l is lower triangular if m <= n); the elements above the diagonal, with the array tau, repre reflectors (see further details). where lcmp = lcm / nprow with lcm = ilcm( nprow, npcol ) iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), the (n-m)-th superdiagonal contain the m by n lower trapezoidal matrix l; the remaining elements, with th elementary reflectors (see further details). the (n-m)-th superdiagonal contain the m by n lower trapezoidal matrix l; the remaining elements, with th elementary reflectors (see further details). psgeqpf computes a qr factorization with column pivoting of upper trapezoidal matrix r (r is upper triangular if m >= n); the elements below the diagonal, with the array tau reflectors (see further details). upper trapezoidal matrix r (r is upper triangular if m >= n); the elements below the diagonal, with the array tau reflectors (see further details). by psgetrf. ipiv(i) -> the global row local row i was swapped with. this array is tied to the distribute and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). the lu decomposition with partial pivoting and row interchanges i tation matrix, l is unit lower triangular, and u is upper triangular. if equed is not 'n', the matrix a(ia:ia+n-1,ja:ja+n-1) has been equilibrated with a(ia:ia+n-1,ja:ja+n-1), af(iaf:iaf+n-1,jaf:jaf+n-1), distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using partial pivoting with row interchanges the factorization has the form sub( a ) = p * l * u, where p is a 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 with keeps track of the pivoting information. ipiv(i) is the global row index the local row i was swapped with. thi with a general n-by-n distributed matrix sub( a ) using the l sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a or a**t and upper trapezoidal matrix r (r is upper triangular if n >= m); the elements below the diagonal, with the array taua elementary reflectors (see further details). and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). 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 if m >= n, elements on and below the diagonal in the first nb columns, with the array tauq, represent the orthogona elements above the diagonal in the first nb rows, with the reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, this informatio specifies the computation done by pslaebz = 0 : find an interval with desired values of n(w) at th = 1 : find a floating point number contained in the initial work (local workspace ) real array, dimension (lwork) lwork = 6*n + 2*np*nq, with nq = numroc( n, nb_q, mycol, iqcol, npcol ) where z = q'u, u is a vector of length n with ones in th 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 this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. the eigenvectors on output. the eigenvectors are distributed in a block cyclic manner in both dimensions, with 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 k-th subdiagonal in the first nb columns are overwritten with the corresponding elements of the reduced distribute array tau, represent the matrix q as a product of elementary to 1. indeed, i suspect that ib should always be set to 1 or ignored with 1 used in its place pslamr1d has not been tested except withint the contect of ( max(abs(a(i,j))), norm = 'm' or 'm' with ia <= i <= ia+m-1 ( 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, 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. the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligned with the distributed matrix a, and replicated across ever where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), before entry, the incremented array sub( x ) must contain the vector x. on exit, it is overwritten with the vector v ix (global input) integer the k-by-k triangular factor of the block reflector asso- ciated with v. if direct = 'f', t is upper triangular where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), it contains the k-by-k triangular factor of the block reflector associated with v. t is lower triangular work (local workspace) real array, on entry, the value scale in the equation above. on exit, scale is overwritten with scl , the scaling facto on exit, if uplo = 'u', the last nb columns have been reduced to tridiagonal form, with the diagonal elements overwritin diagonal with the array tau, represent the orthogonal matrix gular matrix r, and elements n-l+1 to n of the first m rows of sub( a ), with the array tau, represent the orthogona on exit, if uplo = 'u', the upper triangle of the distributed matrix sub( a ) is overwritten with the upper triangle of th is overwritten with the lower triangle of the product l' * l. on exit, if uplo = 'u', the upper triangle of the distributed matrix sub( a ) is overwritten with the upper triangle of th is overwritten with the lower triangle of the product l' * l. psorg2l generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a psorg2r generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m psorgl2 generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a psorglq generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a psorgql generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a psorgqr generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m psorgr2 generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th psorgrq generates an m-by-n real distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th psorm2l overwrites the general real m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with side = 'l' side = 'r' banded symmetric positive definite distributed matrix with bandwidth bw cholesky factorization is used to factor a reordering of want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded symmetric positive definite distributed matrix with bandwidth bw a(1:n, ja:ja+n-1) = u'*u or l*l' as computed by pspbtrf. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. 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 scal buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones on ted matrix sub( b ). on exit, if info = 0, sub( b ) is over- written with the solution distributed matrix x ib (global input) integer if equed = 'y', the matrix a has been equilibrated with scaling factors given by s. a and af will no = 'n': the matrix a will be copied to af and factored. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. split-off block (see iblock, isplit) and
ordered from smallest to largest withi
= 'e': ("entire matrix")
this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. 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. the different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro the different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro set to twice the underflow threshold 2*pslamch('s') not zero.
if this routine returns with ((mod(info,2).ne.0) .or
eigenvectors did not converge, try setting abstol to
set to twice the underflow threshold 2*pslamch('s') not zero.
if this routine returns with ((mod(info,2).ne.0) .or
eigenvectors did not converge, try setting abstol to
matrix t, and the elements above the first superdiagonal, with the array tau, represent the orthogonal matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the orthogonal matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the orthogonal matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the unitary matrix q as and first subdiagonal of sub( a ) are overwritten by the pstrrfs provides error bounds and backward error estimates for the solution to a system of linear equations with a triangula gular matrix r, and elements m+1 to n of the first m rows of sub( a ), with the array tau, represent the orthogonal matri banded diagonally dominant-like distributed matrix with bandwidth bwl, bwu gaussian elimination without pivoting want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded diagonally dominant-like distributed matrix with bandwidth bwl, bwu routine pzdbtrf must be called first. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. gaussian elimination without pivotin of the matrix into l u. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. trans (global input) character = 'n': solve with a(1:n, ja:ja+n-1) want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded distributed matrix with bandwidth bwl, bwu gaussian elimination with pivoting want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded distributed matrix with bandwidth bwl, bwu routine pzgbtrf must be called first. the diagonal and the first superdiagonal of sub( a ) are overwritten with the upper bidiagonal matrix b; the element unitary matrix q as a product of elementary reflectors, and the diagonal and the first superdiagonal of sub( a ) are overwritten with the upper bidiagonal matrix b; the element unitary matrix q as a product of elementary reflectors, and the column scale factors, chosen to try to make the largest entry in each row and column of the distributed matrix b with element the upper triangle and the first subdiagonal of sub( a ) are overwritten with the upper hessenberg matrix h, and the ele sent the unitary matrix q as a product of elementary the upper triangle and the first subdiagonal of sub( a ) are overwritten with the upper hessenberg matrix h, and the ele sent the unitary matrix q as a product of elementary lower trapezoidal matrix l (l is lower triangular if m <= n); the elements above the diagonal, with the array tau, repre reflectors (see further details). lower trapezoidal matrix l (l is lower triangular if m <= n); the elements above the diagonal, with the array tau, repre reflectors (see further details). where lcmp = lcm / nprow with lcm = ilcm( nprow, npcol ) iroffa = mod( ia-1, mb_a ), icoffa = mod( ja-1, nb_a ), the (n-m)-th superdiagonal contain the m by n lower trapezoidal matrix l; the remaining elements, with th elementary reflectors (see further details). the (n-m)-th superdiagonal contain the m by n lower trapezoidal matrix l; the remaining elements, with th elementary reflectors (see further details). pzgeqpf computes a qr factorization with column pivoting of upper trapezoidal matrix r (r is upper triangular if m >= n); the elements below the diagonal, with the array tau reflectors (see further details). upper trapezoidal matrix r (r is upper triangular if m >= n); the elements below the diagonal, with the array tau reflectors (see further details). by pzgetrf. ipiv(i) -> the global row local row i was swapped with. this array is tied to the distribute and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). the lu decomposition with partial pivoting and row interchanges i tation matrix, l is unit lower triangular, and u is upper triangular. if equed is not 'n', the matrix a(ia:ia+n-1,ja:ja+n-1) has been equilibrated with a(ia:ia+n-1,ja:ja+n-1), af(iaf:iaf+n-1,jaf:jaf+n-1), distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using partial pivoting with row interchanges the factorization has the form sub( a ) = p * l * u, where p is a 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 with keeps track of the pivoting information. ipiv(i) is the global row index the local row i was swapped with. thi with a general n-by-n distributed matrix sub( a ) using the l sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a, a**t or a**h upper trapezoidal matrix r (r is upper triangular if n >= m); the elements below the diagonal, with the array taua elementary reflectors (see further details). and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix r; the remaining elements, with the arra elementary reflectors (see further details). different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro lwork = n + ( np0 + mq0 + nb ) * nb, with np0 = numroc( max( n, nb, 2 ), nb, 0, 0, nprow set to twice the underflow threshold 2*pdlamch('s') not zero.
if this routine returns with ((mod(info,2).ne.0) .or
eigenvectors did not converge, try setting abstol to
set to twice the underflow threshold 2*pdlamch('s') not zero.
if this routine returns with ((mod(info,2).ne.0) .or
eigenvectors did not converge, try setting abstol to
matrix t, and the elements above the first superdiagonal, with the array tau, represent the unitary matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the unitary matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the unitary matrix q as and first subdiagonal of sub( a ) are overwritten by the matrix t, and the elements above the first superdiagonal, with the array tau, represent the unitary matrix q as and first subdiagonal of sub( a ) are overwritten by the if m >= n, elements on and below the diagonal in the first nb columns, with the array tauq, represent the unitar elements above the diagonal in the first nb rows, with the a. reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, thi the eigenvectors on output. the eigenvectors are distributed in a block cyclic manner in both dimensions, with 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 k-th subdiagonal in the first nb columns are overwritten with the corresponding elements of the reduced distribute array tau, represent the matrix q as a product of elementary to 1. indeed, i suspect that ib should always be set to 1 or ignored with 1 used in its place pzlamr1d has not been tested except withint the contect of ( max(abs(a(i,j))), norm = 'm' or 'm' with ia <= i <= ia+m-1 ( 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, 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. the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligned with the distributed matrix a, and replicated across ever where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), before entry, the incremented array sub( x ) must contain the vector x. on exit, it is overwritten with the vector v ix (global input) integer the k-by-k triangular factor of the block reflector asso- ciated with v. if direct = 'f', t is upper triangular where lcmq = lcm / npcol with lcm = iclm( nprow, npcol ) iroffv = mod( iv-1, mb_v ), icoffv = mod( jv-1, nb_v ), it contains the k-by-k triangular factor of the block reflector associated with v. t is lower triangular work (local workspace) complex*16 array, on entry, the value scale in the equation above. on exit, scale is overwritten with scl , the scaling facto on exit, if uplo = 'u', the last nb columns have been reduced to tridiagonal form, with the diagonal elements overwritin diagonal with the array tau, represent the unitary matrix q gular matrix r, and elements n-l+1 to n of the first m rows of sub( a ), with the array tau, represent the unitary matri on exit, if uplo = 'u', the upper triangle of the distributed matrix sub( a ) is overwritten with the upper triangle of th is overwritten with the lower triangle of the product l' * l. on exit, if uplo = 'u', the upper triangle of the distributed matrix sub( a ) is overwritten with the upper triangle of th is overwritten with the lower triangle of the product l' * l. 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 banded symmetric positive definite distributed matrix with bandwidth bw cholesky factorization is used to factor a reordering of want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. banded symmetric positive definite distributed matrix with bandwidth bw a(1:n, ja:ja+n-1) = u'*u or l*l' as computed by pzpbtrf. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. 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 scal buted matrix b with elements b(i,j) = s(i)*a(i,j)*s(j) has ones on ted matrix sub( b ). on exit, if info = 0, sub( b ) is over- written with the solution distributed matrix x ib (global input) integer if equed = 'y', the matrix a has been equilibrated with scaling factors given by s. a and af will no = 'n': the matrix a will be copied to af and factored. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. want to find errors with min( ), so if no error, set it to a bi descriptor multiplier. 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. pztrrfs provides error bounds and backward error estimates for the solution to a system of linear equations with a triangula gular matrix r, and elements m+1 to n of the first m rows of sub( a ), with the array tau, represent the unitary matrix pzung2l generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pzung2r generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pzungl2 generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pzunglq generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined a pzungql generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a pzungqr generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal columns, which is defined a m pzungr2 generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th pzungrq generates an m-by-n complex distributed matrix q denoting a(ia:ia+m-1,ja:ja+n-1) with orthonormal rows, which is defined as th pzunm2l overwrites the general complex m-by-n distributed matrix sub( c ) = c(ic:ic+m-1,jc:jc+n-1) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with 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) with side = 'l' side = 'r' sdbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. sdttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form u * x = b, u**t * x = b, or u**h * x = b, with factors of the tridiagonal matrix a from the lu factorizatio compute lu factors with partial pivoting ( pt = lu t - real array of dimension ( ldt, n ). before entry with uplo = 'u' or 'u', the leading n by triangular matrix and the strictly lower triangular part of zdbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. zdttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form u * x = b, u**t * x = b, or u**h * x = b, with factors of the tridiagonal matrix a from the lu factorizatio 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. t - complex*16 array of dimension ( ldt, n ). before entry with uplo = 'u' or 'u', the leading n by triangular matrix and the strictly lower triangular part of |
| within within 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 specifies which eigenvectors should be reorthogonalized. eigenvectors that correspond to eigenvalues which are within however, if the workspace is insufficient (see lwork), specifies which eigenvectors should be reorthogonalized. eigenvectors that correspond to eigenvalues which are within however, if the workspace is insufficient (see lwork), 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 products. x and v are aligned with the distributed matrix a, this information is implicitly contained within iv, ix, descv, and descx notes perform the local computation within a process colum perform the local computation within a process colum perform the local computation within a process colum perform the local computation within a process colum 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 the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe 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. x and v are aligned with the distributed matrix a, this information is implicitly contained within iv, ix, descv, and descx notes all rotn row transforms are all complete through some column tmp. (loops within 190 are then applied in a block fashion. perform the local computation within a process colum perform the local computation within a process colum the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe split-off block (see iblock, isplit) and
ordered from smallest to largest within
= '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. specifies which eigenvectors should be reorthogonalized. eigenvectors that correspond to eigenvalues which are within however, if the workspace is insufficient (see lwork), specifies which eigenvectors should be reorthogonalized. eigenvectors that correspond to eigenvalues which are within however, if the workspace is insufficient (see lwork), 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 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 x and v are aligned with the distributed matrix a, this information is implicitly contained within iv, ix, descv, and descx notes all rotn row transforms are all complete through some column tmp. (loops within 190 are then applied in a block fashion. perform the local computation within a process colum perform the local computation within a process colum the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe split-off block (see iblock, isplit) and
ordered from smallest to largest within
= '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. specifies which eigenvectors should be reorthogonalized. eigenvectors that correspond to eigenvalues which are within however, if the workspace is insufficient (see lwork), specifies which eigenvectors should be reorthogonalized. eigenvectors that correspond to eigenvalues which are within however, if the workspace is insufficient (see lwork), 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 specifies which eigenvectors should be reorthogonalized. eigenvectors that correspond to eigenvalues which are within however, if the workspace is insufficient (see lwork), specifies which eigenvectors should be reorthogonalized. eigenvectors that correspond to eigenvalues which are within however, if the workspace is insufficient (see lwork), 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 products. x and v are aligned with the distributed matrix a, this information is implicitly contained within iv, ix, descv, and descx notes perform the local computation within a process colum perform the local computation within a process colum perform the local computation within a process colum perform the local computation within a process colum 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 the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe 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. 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 |
| withint withint pclamr1d has not been tested except withint the contect o pdlamr1d has not been tested except withint the contect o pslamr1d has not been tested except withint the contect o pzlamr1d has not been tested except withint the contect o |
| without without cdbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. cdttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form ddbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. ddttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form gaussian elimination without pivotin of the matrix into l u. gaussian elimination without pivotin of the matrix into l u. dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro and sufficient workspace to compute them. (see lwork below.) pcheevx is always able to detect insufficient space without and sufficient workspace to compute them. (see lwork below.) pchegvx is always able to detect insufficient space without subdiagonal elements, we need to see how many bulges we can send through without breaking the consecutive smal denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. this is done without over/underflow as long as the final resul sub( a ) may be full, upper triangular, lower triangular or upper dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a since there is no element-by-element vector multiplication in the blas, this loop must be hardwired in without a blas cal dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a pcsrscl multiplies an n-element complex distributed vector sub( x ) by the real scalar 1/a. this is done without overflow o underflow. gaussian elimination without pivotin of the matrix into l u. gaussian elimination without pivotin of the matrix into l u. dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a safe_min is at least the smallest number that can divide 1.0 without overflow sequence loop. 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 safe_min is at least the smallest number that can divide 1.0 without overflow count (output) integer denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. this is done without over/underflow as long as the final resul sub( a ) may be full, upper triangular, lower triangular or upper dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a since there is no element-by-element vector multiplication in the blas, this loop must be hardwired in without a blas cal dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a pdrscl multiplies an n-element real distributed vector sub( x ) by the real scalar 1/a. this is done without overflow or underflow a 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 the different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro the different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro and sufficient workspace to compute them. (see lwork below.) pdsyevx is always able to detect insufficient space without and sufficient workspace to compute them. (see lwork below.) pdsygvx is always able to detect insufficient space without gaussian elimination without pivotin of the matrix into l u. gaussian elimination without pivotin of the matrix into l u. dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a safe_min is at least the smallest number that can divide 1.0 without overflow sequence loop. 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 safe_min is at least the smallest number that can divide 1.0 without overflow count (output) integer denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. this is done without over/underflow as long as the final resul sub( a ) may be full, upper triangular, lower triangular or upper dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a since there is no element-by-element vector multiplication in the blas, this loop must be hardwired in without a blas cal dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a psrscl multiplies an n-element real distributed vector sub( x ) by the real scalar 1/a. this is done without overflow or underflow a 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 the different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro the different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro and sufficient workspace to compute them. (see lwork below.) pssyevx is always able to detect insufficient space without and sufficient workspace to compute them. (see lwork below.) pssygvx is always able to detect insufficient space without gaussian elimination without pivotin of the matrix into l u. pzdrscl multiplies an n-element complex distributed vector sub( x ) by the real scalar 1/a. this is done without overflow o underflow. gaussian elimination without pivotin of the matrix into l u. dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro and sufficient workspace to compute them. (see lwork below.) pzheevx is always able to detect insufficient space without and sufficient workspace to compute them. (see lwork below.) pzhegvx is always able to detect insufficient space without subdiagonal elements, we need to see how many bulges we can send through without breaking the consecutive smal denoting a(ia:ia+m-1,ja:ja+n-1) by the real scalar cto/cfrom. this is done without over/underflow as long as the final resul sub( a ) may be full, upper triangular, lower triangular or upper dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a since there is no element-by-element vector multiplication in the blas, this loop must be hardwired in without a blas cal dtype_a = 501 or 502 can be used interchangeably without any other change tridiagonal matrix be aligned with each other. because of this, a sdbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. sdttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form zdbtrf computes an lu factorization of a real m-by-n band matrix a without using partial pivoting with row interchanges this is the unblocked version of the algorithm, calling level 2 blas. zdttrf computes an lu factorization of a complex tridiagonal matrix a using elimination without partial pivoting the factorization has the form |
| won won copy the matrix t so it won't be destroyed in factorization copy the matrix t so it won't be destroyed in factorization |
| words words of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on since the user cannot know a priori what value nsplit will have, n words must be reserved for isplit. work (local workspace) double precision array, of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on since the user cannot know a priori what value nsplit will have, n words must be reserved for isplit. work (local workspace) real array, dimension ( max( 5*n, 7 ) ) of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on of the divide and conquer algorithm as a task-parallel algorithm. this formula in words is: no processor may have more than on |
| work work the block size must not exceed the limit set by the size of the local arrays work13 and work31 if .true., then apply any column reflections to z as well. if .false., then do no additional work on z z (global input/output) complex array, (ldz,*) the block size must not exceed the limit set by the size of the local arrays work13 and work31 if .true., then apply any column reflections to z as well. if .false., then do no additional work on z z (global input/output) double precision array, (ldz,*) since every 2nd subdiagonal is guaranteed to be zero. this routine does no parallel work arguments skip all the work if the block size is one work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic comple global dimension (m, n), local dimension (mp, nq) rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to working precision work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic complex array locc(ja+n-1) ) a (local input/workspace) block cyclic complex array locc(ja+n-1) ) a (local input/workspace) block cyclic complex array local dimension ( lld_a, locc(ja+n-1) ) with guaranteed high relative accuracy," by demmel and kahan, lapack working note #3 see "on the correctness of parallel bisection in floating pchengst also calls pchegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb codes (either the serial, chetrd, or the parallel code, pchettrd) when the workspace provided by the user is adequate work (local workspace/local output) complex array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace) complex array, dimension (lwork work (local workspace) complex array, dimension (lwork buf (local output) complex array of size lwork lwork (global input) integer determine the number of columns we have so we can check workspac work (local workspace) complex array, dimension (nb further details i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. work (local workspace) real array dimension (lwork nq0 if norm = '1', 'o' or '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 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 work (local workspace) complex array, dimension (lwork if side = 'l', work (local workspace) complex array work (local workspace) complex array, dimension (lwork if side = 'l', work (local workspace) complex array buf (local output) complex array of size lwork lwork (global input) integer already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pclapiv. work (local workspace) complex array, dimension (nb_a further details work (local workspace) complex array, dimension (lwork work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. machine precision (in particular, if rcond = 0), the matrix is singular to working precision. this condition i error bounds are not computed. work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be orthogonalize vectors that are on different processes. the extent of orthogonalization is controlled by the input parameter lwork process. pcstein decides on the allocation of work among the work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace) complex array additional workspace may be required if pclattrs is updated work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic double precisio global dimension (m, n), local dimension (mp, nq) rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to working precision work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace) double precision array, dimension (lwork buf (local output) double precision array of size lwork lwork (global input) integer work (local workspace ) double precision array, dimension (lwork np = numroc( n, mb_q, myrow, iqrow, nprow ) work (local workspace/output) double precision array this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. work (local workspace) double precision array, dimension (lwork lwork (local input) integer dimension of work determine the number of columns we have so we can check workspac work (local workspace) double precision array, dimension (nb further details i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. work (local workspace) double precision array dimension (lwork nq0 if norm = '1', 'o' or '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 work (local workspace) double precision dimension (lwork work (local workspace) double precision dimension (lwork work (local workspace) double precision array, dimension (lwork if side = 'l', work (local workspace) double precision array work (local workspace) double precision array, dimension (lwork if side = 'l', work (local workspace) double precision array buf (local output) double precision array of size lwork lwork (global input) integer work (local workspace/local output) double precision array lwork (local or global input) integer already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pdlapiv. work (local workspace) double precision array, dimension (nb_a further details work (local workspace) double precision array, dimension (lwork work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. machine precision (in particular, if rcond = 0), the matrix is singular to working precision. this condition i error bounds are not computed. work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be 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. this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. orthogonalize vectors that are on different processes. the extent of orthogonalization is controlled by the input parameter lwork process. pdstein decides on the allocation of work among the a (local input/workspace) block cyclic double precision array locc(ja+n-1) ) a (local input/workspace) block cyclic double precision array locc(ja+n-1) ) a (local input/workspace) block cyclic double precision array local dimension ( lld_a, locc(ja+n-1) ) with guaranteed high relative accuracy," by demmel and kahan, lapack working note #3 see "on the correctness of parallel bisection in floating pdsyngst also calls pdhegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb codes (either the serial, dsytrd, or the parallel code, pdsyttrd) when the workspace provided by the user is adequate work (local workspace/local output) double precision array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace) double precision array, dimension (lwork work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic rea global dimension (m, n), local dimension (mp, nq) rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to working precision work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace) real array, dimension (lwork buf (local output) real array of size lwork lwork (global input) integer work (local workspace ) real array, dimension (lwork np = numroc( n, mb_q, myrow, iqrow, nprow ) work (local workspace/output) real array this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. work (local workspace) real array, dimension (lwork lwork (local input) integer dimension of work determine the number of columns we have so we can check workspac work (local workspace) real array, dimension (nb further details i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. work (local workspace) real array dimension (lwork nq0 if norm = '1', 'o' or '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 work (local workspace) real dimension (lwork work (local workspace) real dimension (lwork work (local workspace) real array, dimension (lwork if side = 'l', work (local workspace) real array work (local workspace) real array, dimension (lwork if side = 'l', work (local workspace) real array buf (local output) real array of size lwork lwork (global input) integer work (local workspace/local output) real array lwork (local or global input) integer already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pslapiv. work (local workspace) real array, dimension (nb_a further details work (local workspace) real array, dimension (lwork work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. machine precision (in particular, if rcond = 0), the matrix is singular to working precision. this condition i error bounds are not computed. work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be 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. this code makes very mild assumptions about floating point arithmetic. it will work on machines with a guard digit i which subtract like the cray x-mp, cray y-mp, cray c-90, or cray-2. orthogonalize vectors that are on different processes. the extent of orthogonalization is controlled by the input parameter lwork process. psstein decides on the allocation of work among the a (local input/workspace) block cyclic double precision array locc(ja+n-1) ) a (local input/workspace) block cyclic real array locc(ja+n-1) ) a (local input/workspace) block cyclic real array local dimension ( lld_a, locc(ja+n-1) ) with guaranteed high relative accuracy," by demmel and kahan, lapack working note #3 see "on the correctness of parallel bisection in floating pssyngst also calls pshegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb codes (either the serial, ssytrd, or the parallel code, pssyttrd) when the workspace provided by the user is adequate work (local workspace/local output) real array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace) real array, dimension (lwork work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic complex*1 global dimension (m, n), local dimension (mp, nq) rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to working precision work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic complex*16 array locc(ja+n-1) ) a (local input/workspace) block cyclic complex*16 array locc(ja+n-1) ) a (local input/workspace) block cyclic complex*16 array local dimension ( lld_a, locc(ja+n-1) ) with guaranteed high relative accuracy," by demmel and kahan, lapack working note #3 see "on the correctness of parallel bisection in floating pzhengst also calls pzhegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb codes (either the serial, zhetrd, or the parallel code, pzhettrd) when the workspace provided by the user is adequate work (local workspace/local output) complex*16 array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace) complex*16 array, dimension (lwork work (local workspace) complex*16 array, dimension (lwork buf (local output) complex*16 array of size lwork lwork (global input) integer determine the number of columns we have so we can check workspac work (local workspace) complex*16 array, dimension (nb further details i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. work (local workspace) double precision array dimension (lwork nq0 if norm = '1', 'o' or '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 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 work (local workspace) complex*16 array, dimension (lwork if side = 'l', work (local workspace) complex*16 array work (local workspace) complex*16 array, dimension (lwork if side = 'l', work (local workspace) complex*16 array buf (local output) complex*16 array of size lwork lwork (global input) integer already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pzlapiv. work (local workspace) complex*16 array, dimension (nb_a further details work (local workspace) complex*16 array, dimension (lwork work (local workspace/local output be overwritten in between calls to routines. work must be check worksiz work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. machine precision (in particular, if rcond = 0), the matrix is singular to working precision. this condition i error bounds are not computed. work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be orthogonalize vectors that are on different processes. the extent of orthogonalization is controlled by the input parameter lwork process. pzstein decides on the allocation of work among the work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace) complex*16 array additional workspace may be required if pzlattrs is updated work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. the block size must not exceed the limit set by the size of the local arrays work13 and work31 if .true., then apply any column reflections to z as well. if .false., then do no additional work on z z (global input/output) real array, (ldz,*) since every 2nd subdiagonal is guaranteed to be zero. this routine does no parallel work arguments skip all the work if the block size is one the block size must not exceed the limit set by the size of the local arrays work13 and work31 if .true., then apply any column reflections to z as well. if .false., then do no additional work on z z (global input/output) complex*16 array, (ldz,*) |
| WORK13 WORK13 the block size must not exceed the limit set by the size of the local arrays WORK13 and work31 the block size must not exceed the limit set by the size of the local arrays WORK13 and work31 the block size must not exceed the limit set by the size of the local arrays WORK13 and work31 the block size must not exceed the limit set by the size of the local arrays WORK13 and work31 |
| WORK31 WORK31 the block size must not exceed the limit set by the size of the local arrays work13 and WORK31 the block size must not exceed the limit set by the size of the local arrays work13 and WORK31 the block size must not exceed the limit set by the size of the local arrays work13 and WORK31 the block size must not exceed the limit set by the size of the local arrays work13 and WORK31 |
| Working Working rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to Working precision siam j. sci. comput., 6:20 (1999), pp. 2223--2236. (see also lapack Working note 132 with guaranteed high relative accuracy," by demmel and kahan, lapack Working note #3 see "on the correctness of parallel bisection in floating with guaranteed high relative accuracy," by demmel and kahan, lapack Working note #3 see "on the correctness of parallel bisection in floating machine precision (in particular, if rcond = 0), the matrix is singular to Working precision. this condition i error bounds are not computed. rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to Working precision > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while Working on the submatrix lying i machine precision (in particular, if rcond = 0), the matrix is singular to Working precision. this condition i error bounds are not computed. > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while Working on the submatrix lying i > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while Working on the submatrix lying i with guaranteed high relative accuracy," by demmel and kahan, lapack Working note #3 see "on the correctness of parallel bisection in floating with guaranteed high relative accuracy," by demmel and kahan, lapack Working note #3 see "on the correctness of parallel bisection in floating rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to Working precision > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while Working on the submatrix lying i machine precision (in particular, if rcond = 0), the matrix is singular to Working precision. this condition i error bounds are not computed. > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while Working on the submatrix lying i > 0: the algorithm failed to compute the info/(n+1) th eigenvalue while Working on the submatrix lying i with guaranteed high relative accuracy," by demmel and kahan, lapack Working note #3 see "on the correctness of parallel bisection in floating with guaranteed high relative accuracy," by demmel and kahan, lapack Working note #3 see "on the correctness of parallel bisection in floating rcond is less than the machine precision (in particular, if rcond = 0), the matrix is singular to Working precision siam j. sci. comput., 6:20 (1999), pp. 2223--2236. (see also lapack Working note 132 with guaranteed high relative accuracy," by demmel and kahan, lapack Working note #3 see "on the correctness of parallel bisection in floating with guaranteed high relative accuracy," by demmel and kahan, lapack Working note #3 see "on the correctness of parallel bisection in floating machine precision (in particular, if rcond = 0), the matrix is singular to Working precision. this condition i error bounds are not computed. |
| workloads workloads make sure it's divisible by lcm (we want even workloads! make sure it's divisible by lcm (we want even workloads! make sure it's divisible by lcm (we want even workloads! make sure it's divisible by lcm (we want even workloads! |
| works works 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 works eigenvalues i+1 to ihi have already converged. either l = ilo, or factors is not guaranteed to reduce the condition number of sub( a ) but works well in practice notes determine the number of columns we have so we can check workspac i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. factors is not guaranteed to reduce the condition number of sub( a ) but works well in practice notes determine the number of columns we have so we can check workspac i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. factors is not guaranteed to reduce the condition number of sub( a ) but works well in practice notes determine the number of columns we have so we can check workspac i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. factors is not guaranteed to reduce the condition number of sub( a ) but works well in practice notes determine the number of columns we have so we can check workspac i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. 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 works eigenvalues i+1 to ihi have already converged. either l = ilo, or |
| worksize worksize check worksize check worksize check worksize check worksize check worksize check worksize check worksize check worksize check worksize check worksize output minimum worksize check worksize check worksize check worksize check worksize check worksize output minimum worksize check worksize check worksize check worksize check worksize check worksize |
| workspace workspace work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic comple global dimension (m, n), local dimension (mp, nq) work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic complex array locc(ja+n-1) ) a (local input/workspace) block cyclic complex array locc(ja+n-1) ) a (local input/workspace) block cyclic complex array local dimension ( lld_a, locc(ja+n-1) ) space to hold the eigenvectors in z (m .le. descz(n_)) and sufficient workspace to compute them. (see lwork below. computation unless range .eq. 'v'. pchengst also calls pchegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb codes (either the serial, chetrd, or the parallel code, pchettrd) when the workspace provided by the user is adequate work (local workspace/local output) complex array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace) complex array, dimension (lwork work (local workspace) complex array, dimension (lwork v (local workspace) complex pointer into the loca the final return, v = a*w, where est = norm(v)/norm(w) rwork (local workspace) real array, dimension (lrwork lrwork (local input) integer dimension of rwork determine the number of columns we have so we can check workspace work (local workspace) complex array, dimension (nb further details work (local workspace) complex*16 array, dimension ( lwork lwork (local input) integer work (local workspace) real array dimension (lwork nq0 if norm = '1', 'o' or 'o', 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 work (local workspace) complex array, dimension (lwork if side = 'l', work (local workspace) complex array work (local workspace) complex array, dimension (lwork if side = 'l', work (local workspace) complex array work (local workspace) complex array, dimension (nb_a further details work (local workspace) complex array, dimension (lwork work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be processes and then calls sstein2 (modified lapack routine) on each individual process. if insufficient workspace is allocated, th work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace) complex array additional workspace may be required if pclattrs is updated work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic double precisio global dimension (m, n), local dimension (mp, nq) work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace) double precision array, dimension (lwork v (local workspace) double precision pointer into the loca the final return, v = a*w, where est = norm(v)/norm(w) work (local workspace ) double precision array, dimension (lwork np = numroc( n, mb_q, myrow, iqrow, nprow ) work (local workspace/output) double precision array qbuf (workspace) double precision array, dimension 3* ctot (workspace) integer array, dimension( npcol, 4) qbuf (workspace) double precision array, dimension 3* work (local workspace) double precision array, dimension (lwork lwork (local input) integer dimension of work determine the number of columns we have so we can check workspace work (local workspace) double precision array, dimension (nb further details work (local workspace) complex*16 array, dimension ( lwork lwork (local input) integer work (local workspace) double precision array dimension (lwork nq0 if norm = '1', 'o' or 'o', 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 work (local workspace) double precision dimension (lwork work (local workspace) double precision dimension (lwork work (local workspace) double precision array, dimension (lwork if side = 'l', work (local workspace) double precision array work (local workspace) double precision array, dimension (lwork if side = 'l', work (local workspace) double precision array work (local workspace/local output) double precision array lwork (local or global input) integer work (local workspace) double precision array, dimension (nb_a further details work (local workspace) double precision array, dimension (lwork work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace) double precision array work (local workspace/output) double precision array on output, work(1) returns the workspace needed. processes and then calls dstein2 (modified lapack routine) on each individual process. if insufficient workspace is allocated, th a (local input/workspace) block cyclic double precision array locc(ja+n-1) ) a (local input/workspace) block cyclic double precision array locc(ja+n-1) ) a (local input/workspace) block cyclic double precision array local dimension ( lld_a, locc(ja+n-1) ) space to hold the eigenvectors in z (m .le. descz(n_)) and sufficient workspace to compute them. (see lwork below. computation unless range .eq. 'v'. pdsyngst also calls pdhegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb codes (either the serial, dsytrd, or the parallel code, pdsyttrd) when the workspace provided by the user is adequate work (local workspace/local output) double precision array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace) double precision array, dimension (lwork work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) double precision array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic rea global dimension (m, n), local dimension (mp, nq) work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace) real array, dimension (lwork v (local workspace) real pointer into the loca the final return, v = a*w, where est = norm(v)/norm(w) work (local workspace ) real array, dimension (lwork np = numroc( n, mb_q, myrow, iqrow, nprow ) work (local workspace/output) real array qbuf (workspace) real array, dimension 3* ctot (workspace) integer array, dimension( npcol, 4) qbuf (workspace) real array, dimension 3* work (local workspace) real array, dimension (lwork lwork (local input) integer dimension of work determine the number of columns we have so we can check workspace work (local workspace) real array, dimension (nb further details work (local workspace) complex*16 array, dimension ( lwork lwork (local input) integer work (local workspace) real array dimension (lwork nq0 if norm = '1', 'o' or 'o', 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 work (local workspace) real dimension (lwork work (local workspace) real dimension (lwork work (local workspace) real array, dimension (lwork if side = 'l', work (local workspace) real array work (local workspace) real array, dimension (lwork if side = 'l', work (local workspace) real array work (local workspace/local output) real array lwork (local or global input) integer work (local workspace) real array, dimension (nb_a further details work (local workspace) real array, dimension (lwork work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace) real array, dimension ( max( 5*n, 7 ) lwork (local input) integer work (local workspace/output) real array on output, work(1) returns the workspace needed. processes and then calls sstein2 (modified lapack routine) on each individual process. if insufficient workspace is allocated, th a (local input/workspace) block cyclic double precision array locc(ja+n-1) ) a (local input/workspace) block cyclic real array locc(ja+n-1) ) a (local input/workspace) block cyclic real array local dimension ( lld_a, locc(ja+n-1) ) space to hold the eigenvectors in z (m .le. descz(n_)) and sufficient workspace to compute them. (see lwork below. computation unless range .eq. 'v'. pssyngst also calls pshegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb codes (either the serial, ssytrd, or the parallel code, pssyttrd) when the workspace provided by the user is adequate work (local workspace/local output) real array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace) real array, dimension (lwork work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) real array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be offset to workspace for upper triangular facto work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic complex*1 global dimension (m, n), local dimension (mp, nq) work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. a (local input/workspace) block cyclic complex*16 array locc(ja+n-1) ) a (local input/workspace) block cyclic complex*16 array locc(ja+n-1) ) a (local input/workspace) block cyclic complex*16 array local dimension ( lld_a, locc(ja+n-1) ) space to hold the eigenvectors in z (m .le. descz(n_)) and sufficient workspace to compute them. (see lwork below. computation unless range .eq. 'v'. pzhengst also calls pzhegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb codes (either the serial, zhetrd, or the parallel code, pzhettrd) when the workspace provided by the user is adequate work (local workspace/local output) complex*16 array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work( 1 ) returns the minimal and optimal lwork. work (local workspace) complex*16 array, dimension (lwork work (local workspace) complex*16 array, dimension (lwork v (local workspace) complex*16 pointer into the loca the final return, v = a*w, where est = norm(v)/norm(w) rwork (local workspace) double precision array, dimension (lrwork lrwork (local input) integer dimension of rwork determine the number of columns we have so we can check workspace work (local workspace) complex*16 array, dimension (nb further details work (local workspace) complex*16 array, dimension ( lwork lwork (local input) integer work (local workspace) double precision array dimension (lwork nq0 if norm = '1', 'o' or 'o', 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 work (local workspace) complex*16 array, dimension (lwork if side = 'l', work (local workspace) complex*16 array work (local workspace) complex*16 array, dimension (lwork if side = 'l', work (local workspace) complex*16 array work (local workspace) complex*16 array, dimension (nb_a further details work (local workspace) complex*16 array, dimension (lwork work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output be overwritten in between calls to routines. work must be work (local workspace/local output be overwritten in between calls to routines. work must be processes and then calls dstein2 (modified lapack routine) on each individual process. if insufficient workspace is allocated, th work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace) complex*16 array additional workspace may be required if pzlattrs is updated work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. work (local workspace/local output) complex*16 array on exit, work(1) returns the minimal and optimal lwork. |
| workspaces workspaces where wpclange, wpclared1d, wpclared2d, wpcgebrd are the workspaces required respectively for the subprogram standard notation where wpdlange, wpdlared1d, wpdlared2d, wpdgebrd are the workspaces required respectively for the subprogram standard notation where wpslange, wpslared1d, wpslared2d, wpsgebrd are the workspaces required respectively for the subprogram standard notation where wpzlange, wpzlared1d, wpzlared2d, wpzgebrd are the workspaces required respectively for the subprogram standard notation |
| worst worst publicly released versions should be large enough to handle the worst machine around. note that this has no effec publicly released versions should be large enough to handle the worst machine around. note that this has no effec |
| worth worth if rowcnd >= 0.1 and amax is neither too large nor too small, it is not worth scaling by r(ia:ia+m-1) colcnd (global output) real ia <= i <= ia+n-1 and ja <= j <= ja+n-1. if scond >= 0.1 and amax is neither too large nor too small, it is not worth if rowcnd >= 0.1 and amax is neither too large nor too small, it is not worth scaling by r(ia:ia+m-1) colcnd (global output) double precision ia <= i <= ia+n-1 and ja <= j <= ja+n-1. if scond >= 0.1 and amax is neither too large nor too small, it is not worth if rowcnd >= 0.1 and amax is neither too large nor too small, it is not worth scaling by r(ia:ia+m-1) colcnd (global output) real ia <= i <= ia+n-1 and ja <= j <= ja+n-1. if scond >= 0.1 and amax is neither too large nor too small, it is not worth if rowcnd >= 0.1 and amax is neither too large nor too small, it is not worth scaling by r(ia:ia+m-1) colcnd (global output) double precision ia <= i <= ia+n-1 and ja <= j <= ja+n-1. if scond >= 0.1 and amax is neither too large nor too small, it is not worth |
| would would determine the effect of starting the double-shift qr iteration at row m, and see if this would make h(m,m-1 locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a assume that its process grid has dimension r x c. locr( k ) denotes the number of elements of k that a process would receive if k wer locc( k ) denotes the number of elements of k that a process would locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locp( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locq( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a seeing the effect of starting a double shift qr iteration given by h44, h33, & h43h34 and see if this would make locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a assume that its process grid has dimension r x c. locr( k ) denotes the number of elements of k that a process would receive if k wer locc( k ) denotes the number of elements of k that a process would locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a seeing the effect of starting a double shift qr iteration given by h44, h33, & h43h34 and see if this would make locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locp( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locq( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a into a single character string. for example, uplo = 'u', trans = 't', and diag = 'n' for a triangular routine would locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a assume that its process grid has dimension r x c. locr( k ) denotes the number of elements of k that a process would receive if k wer locc( k ) denotes the number of elements of k that a process would locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a seeing the effect of starting a double shift qr iteration given by h44, h33, & h43h34 and see if this would make locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locp( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locq( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a assume that its process grid has dimension r x c. locr( k ) denotes the number of elements of k that a process would receive if k wer locc( k ) denotes the number of elements of k that a process would locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locp( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locq( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a seeing the effect of starting a double shift qr iteration given by h44, h33, & h43h34 and see if this would make locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the r processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a locr( k ) denotes the number of elements of k that a process would receive if k were distributed over the p processes of it similarly, locc( k ) denotes the number of elements of k that a determine the effect of starting the double-shift qr iteration at row m, and see if this would make h(m,m-1 |
| WPCGEBRD WPCGEBRD watobd = max(max(wpclange,WPCGEBRD) |
| WPCLANGE WPCLANGE watobd = max(max(WPCLANGE,wpcgebrd) |
| WPCLARED1D WPCLARED1D where wpclange, WPCLARED1D, wpclared2d, wpcgebrd are th pclange, pslared1d, pslared2d, pcgebrd. using the |
| WPCLARED2D WPCLARED2D watobd = max(max(wpclange,wpcgebrd), max(WPCLARED2D,wp(pre)lared1d)) where wpclange, wpclared1d, wpclared2d, wpcgebrd are the |
| WPCORMBRPRT WPCORMBRPRT max(wcbdsqr, max(wantu*wpcormbrqln, wantvt*WPCORMBRPRT)) where |
| WPCORMBRQLN WPCORMBRQLN max(wcbdsqr, max(wantu*WPCORMBRQLN, wantvt*wpcormbrprt)) where |
| WPDGEBRD WPDGEBRD watobd = max(max(wpdlange,WPDGEBRD) |
| WPDLANGE WPDLANGE watobd = max(max(WPDLANGE,wpdgebrd) |
| WPDLARED1D WPDLARED1D where wpdlange, WPDLARED1D, wpdlared2d, wpdgebrd are th pdlange, pdlared1d, pdlared2d, pdgebrd. using the wpzlange = mp, WPDLARED1D = nq0 wpzgebrd = nb*(mp + nq + 1) + nq, |
| WPDLARED2D WPDLARED2D watobd = max(max(wpdlange,wpdgebrd), max(WPDLARED2D,wp(pre)lared1d)) where wpdlange, wpdlared1d, wpdlared2d, wpdgebrd are the wpdlared1d = nq0, WPDLARED2D = mp0 |
| WPDORMBRPRT WPDORMBRPRT max(wdbdsqr, max(wantu*wpdormbrqln, wantvt*WPDORMBRPRT)) where |
| WPDORMBRQLN WPDORMBRQLN max(wdbdsqr, max(wantu*WPDORMBRQLN, wantvt*wpdormbrprt)) where |
| WPSGEBRD WPSGEBRD watobd = max(max(wpslange,WPSGEBRD) |
| WPSLANGE WPSLANGE watobd = max(max(WPSLANGE,wpsgebrd) |
| WPSLARED1D WPSLARED1D wpclange = mp, WPSLARED1D = nq0 wpcgebrd = nb*(mp + nq + 1) + nq, where wpslange, WPSLARED1D, wpslared2d, wpsgebrd are th pslange, pslared1d, pslared2d, psgebrd. using the |
| WPSLARED2D WPSLARED2D wpslared1d = nq0, WPSLARED2D = mp0 watobd = max(max(wpslange,wpsgebrd), max(WPSLARED2D,wp(pre)lared1d)) where wpslange, wpslared1d, wpslared2d, wpsgebrd are the |
| WPSORMBRPRT WPSORMBRPRT max(wsbdsqr, max(wantu*wpsormbrqln, wantvt*WPSORMBRPRT)) where |
| WPSORMBRQLN WPSORMBRQLN max(wsbdsqr, max(wantu*WPSORMBRQLN, wantvt*wpsormbrprt)) where |
| WPZGEBRD WPZGEBRD watobd = max(max(wpzlange,WPZGEBRD) |
| WPZLANGE WPZLANGE watobd = max(max(WPZLANGE,wpzgebrd) |
| WPZLARED1D WPZLARED1D where wpzlange, WPZLARED1D, wpzlared2d, wpzgebrd are th pzlange, pdlared1d, pdlared2d, pzgebrd. using the |
| WPZLARED2D WPZLARED2D watobd = max(max(wpzlange,wpzgebrd), max(WPZLARED2D,wp(pre)lared1d)) where wpzlange, wpzlared1d, wpzlared2d, wpzgebrd are the |
| WPZORMBRPRT WPZORMBRPRT max(wzbdsqr, max(wantu*wpzormbrqln, wantvt*WPZORMBRPRT)) where |
| WPZORMBRQLN WPZORMBRQLN max(wzbdsqr, max(wantu*WPZORMBRQLN, wantvt*wpzormbrprt)) where |
| writing writing the following method uses more flops than necessary but does not necessitate the writing of a new blas routine the following method uses more flops than necessary but does not necessitate the writing of a new blas routine the following method uses more flops than necessary but does not necessitate the writing of a new blas routine the following method uses more flops than necessary but does not necessitate the writing of a new blas routine the following method uses more flops than necessary but does not necessitate the writing of a new blas routine the following method uses more flops than necessary but does not necessitate the writing of a new blas routine the following method uses more flops than necessary but does not necessitate the writing of a new blas routine the following method uses more flops than necessary but does not necessitate the writing of a new blas routine |
| written written complex temporary workspace. this space may be overwritten in between calls to routines. work must b on exit, work( 1 ) contains the minimal lwork. m-by-n matrix a, optionally computing the left and/or right singular vectors. the svd is written a a = u * sigma * transpose(v) scaling of the matrix a, but if equilibration is used, a is overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n' the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the unitary matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the unitary matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the unitary matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the unitary matrix q as a ted matrix sub( b ). on exit, if info = 0, sub( b ) is over- written with the solution distributed matrix x ib (global input) integer double precision temporary workspace. this space may be overwritten in between calls to routines. work must b on exit, work( 1 ) contains the minimal lwork. m-by-n matrix a, optionally computing the left and/or right singular vectors. the svd is written a a = u * sigma * transpose(v) scaling of the matrix a, but if equilibration is used, a is overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n' ted matrix sub( b ). on exit, if info = 0, sub( b ) is over- written with the solution distributed matrix x ib (global input) integer the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the orthogonal matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the orthogonal matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the orthogonal matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the unitary matrix q as a real temporary workspace. this space may be overwritten in between calls to routines. work must b on exit, work( 1 ) contains the minimal lwork. m-by-n matrix a, optionally computing the left and/or right singular vectors. the svd is written a a = u * sigma * transpose(v) scaling of the matrix a, but if equilibration is used, a is overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n' ted matrix sub( b ). on exit, if info = 0, sub( b ) is over- written with the solution distributed matrix x ib (global input) integer the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the orthogonal matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the orthogonal matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the orthogonal matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the unitary matrix q as a complex*16 temporary workspace. this space may be overwritten in between calls to routines. work must b on exit, work( 1 ) contains the minimal lwork. m-by-n matrix a, optionally computing the left and/or right singular vectors. the svd is written a a = u * sigma * transpose(v) scaling of the matrix a, but if equilibration is used, a is overwritten by diag(r)*a*diag(c) and b by diag(r)*b (if trans='n' the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the unitary matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the unitary matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the unitary matrix q as a the diagonal and first superdiagonal of sub( a ) are over- written by the corresponding elements of the tridiagona with the array tau, represent the unitary matrix q as a ted matrix sub( b ). on exit, if info = 0, sub( b ) is over- written with the solution distributed matrix x ib (global input) integer |
| WSBDSQR WSBDSQR wbdtosvd = size*(wantu*nru + wantvt*ncvt) + max(WSBDSQR |
| www www (see also lapack working note 132) http://www.netlib.org/lapack/lawns/lawn132.p ===================================================================== (see also lapack working note 132) http://www.netlib.org/lapack/lawns/lawn132.p ===================================================================== (see also lapack working note 132) http://www.netlib.org/lapack/lawns/lawn132.p ===================================================================== (see also lapack working note 132) http://www.netlib.org/lapack/lawns/lawn132.p ===================================================================== (see also lapack working note 132) http://www.netlib.org/lapack/lawns/lawn132.p ===================================================================== (see also lapack working note 132) http://www.netlib.org/lapack/lawns/lawn132.p ===================================================================== |
| WZBDSQR WZBDSQR wbdtosvd = size*(wantu*nru + wantvt*ncvt) + max(WZBDSQR |