Back| A- |
| A_i A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i transfer triangle b_i of local matrix to next processor for fillin. overlap the send with the factorization of A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i transfer triangle b_i of local matrix to next processor for fillin. overlap the send with the factorization of A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i transfer triangle b_i of local matrix to next processor for fillin. overlap the send with the factorization of A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i transfer triangle b_i of local matrix to next processor for fillin. overlap the send with the factorization of A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i which needs it to calculate fillin due to factorization of its main (odd) block A_i |
| A11 A11 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 A11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * A11 a12 a1 a31 a32 a33 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 A11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * A11 a12 a1 a31 a32 a33 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 A11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * A11 a12 a1 a31 a32 a33 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 A11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * A11 a12 a1 a31 a32 a33 |
| A12 A12 * A12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a11 A12 a1 a31 a32 a33 * A12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a11 A12 a1 a31 a32 a33 * A12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a11 A12 a1 a31 a32 a33 * A12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a11 A12 a1 a31 a32 a33 |
| A13 A13 a11 a12 A13 a31 a32 a33 a11 a12 A13 a31 a32 a33 a11 a12 A13 a31 a32 a33 a11 a12 A13 a31 a32 a33 |
| A21 A21 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 A21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a12 a13 A21 a22 a2 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 A21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a12 a13 A21 a22 a2 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 A21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a12 a13 A21 a22 a2 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 A21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a12 a13 A21 a22 a2 |
| A22 A22 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 A22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * a11 a12 a13 a21 A22 a2 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 A22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * a11 a12 a13 a21 A22 a2 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 A22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * a11 a12 a13 a21 A22 a2 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 A22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * a11 a12 a13 a21 A22 a2 |
| A23 A23 * a12 A23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a11 a12 a13 a21 a22 A23 * a12 A23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a11 a12 a13 a21 a22 A23 * a12 A23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a11 a12 a13 a21 a22 A23 * a12 A23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a11 a12 a13 a21 a22 A23 |
| A31 A31 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * A31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a22 a23 A31 a32 a3 here a11, a21 and a31 denote the current block of jb columns a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * A31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a22 a23 A31 a32 a3 here a11, a21 and a31 denote the current block of jb columns a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * A31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a22 a23 A31 a32 a3 here a11, a21 and a31 denote the current block of jb columns a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * A31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a22 a23 A31 a32 a3 here a11, a21 and a31 denote the current block of jb columns |
| A32 A32 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 A32 a43 a54 a65 * m21 m32 m43 m54 m65 a21 a22 a23 a31 A32 a3 here a11, a21 and a31 denote the current block of jb columns a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 A32 a43 a54 a65 * m21 m32 m43 m54 m65 a21 a22 a23 a31 A32 a3 here a11, a21 and a31 denote the current block of jb columns a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 A32 a43 a54 a65 * m21 m32 m43 m54 m65 a21 a22 a23 a31 A32 a3 here a11, a21 and a31 denote the current block of jb columns a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 A32 a43 a54 a65 * m21 m32 m43 m54 m65 a21 a22 a23 a31 A32 a3 here a11, a21 and a31 denote the current block of jb columns |
| A33 A33 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 A33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * a21 a22 a23 a31 a32 A33 here a11, a21 and a31 denote the current block of jb columns * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 A33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * a21 a22 a23 a31 a32 A33 here a11, a21 and a31 denote the current block of jb columns * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 A33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * a21 a22 a23 a31 a32 A33 here a11, a21 and a31 denote the current block of jb columns * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 A33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * a21 a22 a23 a31 a32 A33 here a11, a21 and a31 denote the current block of jb columns |
| a34 a34 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * |
| a42 a42 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked |
| a43 a43 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 |
| a44 a44 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * |
| a45 a45 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * |
| a53 a53 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked |
| a54 a54 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 |
| a55 a55 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * |
| a56 a56 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u5 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * |
| a64 a64 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 * a31 a42 a53 a64 * * m31 m42 m53 m64 * array elements marked * are not used by the routine; elements marked |
| a65 a65 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66 a21 a32 a43 a54 a65 * m21 m32 m43 m54 m65 |
| a66 a66 * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * * a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56 a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u6 a31 a42 a53 a64 * * m31 m42 m53 m64 * * |
| able able if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pcheevx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pchegvx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pdsyevx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pdsygvx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pssyevx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pssygvx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pzheevx is not able to detect thi requested, the user must supply both sufficient if jobz .eq. 'v', nz = m unless the user supplies insufficient space and pzhegvx is not able to detect thi requested, the user must supply both sufficient |
| about about 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 get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid this code makes very mild assumptions about floating poin add/subtract, or on those binary machines without guard digits get information about new grid get information about new grid get information about new grid get information about new grid this code makes very mild assumptions about floating poin add/subtract, or on those binary machines without guard digits get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid this code makes very mild assumptions about floating poin add/subtract, or on those binary machines without guard digits get information about new grid get information about new grid get information about new grid get information about new grid this code makes very mild assumptions about floating poin add/subtract, or on those binary machines without guard digits get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid get information about new grid 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 |
| above above unitary matrix q as a product of elementary reflectors, and the elements above the first superdiagonal, with the arra elementary reflectors. if m < n, the diagonal and the first unitary matrix q as a product of elementary reflectors, and the elements above the first superdiagonal, with the arra elementary reflectors. if m < n, the diagonal and the first 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). sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, repre- sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the unitary matrix q as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the unitary matrix q as a product of the workspaces required for the above subprograms ar wpclange = mp, sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(n,m) by the elements below the diagonal, with the array taua, m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe taua, represent the unitary matrix q as a product of lwork >= max( lwork, nhetrd_lwork ) where lwork is as defined above, an ( nps + 1 ) * nps nhegst_lwopt ) where lwork is as defined above, an ( nps + 1 ) * nps written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal matrix q as a product of elementary reflectors; and elements above the diagonal in the first nb rows, with th of elementary reflectors. jj (global input) integer similar description as ii above rev (global input) integer pieces of the n-by-(n-k+1) general distributed matrix a(ia:ia+n-1,ja:ja+n-k). on exit, the elements on and above with the corresponding elements of the reduced distributed specifies the value to be returned in pclange as described above m (global input) integer scale (local input/local output) real on entry, the value scale in the equation above for the sum of squares. to tridiagonal form, with the diagonal elements overwriting the diagonal elements of sub( a ); the elements above th as a product of elementary reflectors. if uplo = 'l', the orthogonal matrix q as a product of elementary reflectors, and the elements above the first superdiagonal, with th of elementary reflectors. if m < n, the diagonal and the orthogonal matrix q as a product of elementary reflectors, and the elements above the first superdiagonal, with th of elementary reflectors. if m < n, the diagonal and the 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). sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, repre- sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the orthogonal matrix q as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the orthogonal matrix q as a product of the workspaces required for the above subprograms ar wpdlange = mp, sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(n,m) by the elements below the diagonal, with the array taua, m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe taua, represent the orthogonal matrix q as a product of matrix q as a product of elementary reflectors; and elements above the diagonal in the first nb rows, with th of elementary reflectors. jj (global input) integer similar description as ii above rev (global input) integer q matrix into three groups: the first group contains non-zero elements only at and above n1, the second contain pieces of the n-by-(n-k+1) general distributed matrix a(ia:ia+n-1,ja:ja+n-k). on exit, the elements on and above with the corresponding elements of the reduced distributed specifies the value to be returned in pdlange as described above m (global input) integer scale (local input/local output) double precision on entry, the value scale in the equation above for the sum of squares. to tridiagonal form, with the diagonal elements overwriting the diagonal elements of sub( a ); the elements above th q as a product of elementary reflectors. if uplo = 'l', the performance can decrease as the workspace provided increases above the workspace amount shown below for optimal performance, greater workspace may be performance can decrease as the workspace provided increases above the workspace amount shown below for optimal performance, greater workspace may be written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal orthogonal matrix q as a product of elementary reflectors, and the elements above the first superdiagonal, with th of elementary reflectors. if m < n, the diagonal and the orthogonal matrix q as a product of elementary reflectors, and the elements above the first superdiagonal, with th of elementary reflectors. if m < n, the diagonal and the 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). sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, repre- sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the orthogonal matrix q as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the orthogonal matrix q as a product of the workspaces required for the above subprograms ar wpslange = mp, sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(n,m) by the elements below the diagonal, with the array taua, m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe taua, represent the orthogonal matrix q as a product of matrix q as a product of elementary reflectors; and elements above the diagonal in the first nb rows, with th of elementary reflectors. jj (global input) integer similar description as ii above rev (global input) integer q matrix into three groups: the first group contains non-zero elements only at and above n1, the second contain pieces of the n-by-(n-k+1) general distributed matrix a(ia:ia+n-1,ja:ja+n-k). on exit, the elements on and above with the corresponding elements of the reduced distributed specifies the value to be returned in pslange as described above m (global input) integer scale (local input/local output) real on entry, the value scale in the equation above for the sum of squares. to tridiagonal form, with the diagonal elements overwriting the diagonal elements of sub( a ); the elements above th q as a product of elementary reflectors. if uplo = 'l', the performance can decrease as the workspace provided increases above the workspace amount shown below for optimal performance, greater workspace may be performance can decrease as the workspace provided increases above the workspace amount shown below for optimal performance, greater workspace may be written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal unitary matrix q as a product of elementary reflectors, and the elements above the first superdiagonal, with the arra elementary reflectors. if m < n, the diagonal and the first unitary matrix q as a product of elementary reflectors, and the elements above the first superdiagonal, with the arra elementary reflectors. if m < n, the diagonal and the first 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). sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, repre- sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(m,n) by the elements below the diagonal, with the array tau, m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the unitary matrix q as a product of m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe tau, represent the unitary matrix q as a product of the workspaces required for the above subprograms ar wpzlange = mp, sub( a ) which is to be factored. on exit, the elements on and above the diagonal of sub( a ) contain the min(n,m) by the elements below the diagonal, with the array taua, m by m upper triangular matrix r; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n uppe taua, represent the unitary matrix q as a product of lwork >= max( lwork, nhetrd_lwork ) where lwork is as defined above, an ( nps + 1 ) * nps nhegst_lwopt ) where lwork is as defined above, an ( nps + 1 ) * nps written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal written by the corresponding elements of the tridiagonal matrix t, and the elements above the first superdiagonal product of elementary reflectors; if uplo = 'l', the diagonal matrix q as a product of elementary reflectors; and elements above the diagonal in the first nb rows, with th of elementary reflectors. jj (global input) integer similar description as ii above rev (global input) integer pieces of the n-by-(n-k+1) general distributed matrix a(ia:ia+n-1,ja:ja+n-k). on exit, the elements on and above with the corresponding elements of the reduced distributed specifies the value to be returned in pzlange as described above m (global input) integer scale (local input/local output) double precision on entry, the value scale in the equation above for the sum of squares. to tridiagonal form, with the diagonal elements overwriting the diagonal elements of sub( a ); the elements above th as a product of elementary reflectors. if uplo = 'l', the |
| abs abs s = abs( real( h( i,i-1 ) ) ) + abs( real( h( i-1,i-2 ) ) prepare to use wilkinson's shift. x - complex array of dimension at least ( 1 + ( n - 1 )*abs( incx ) ) x - double precision array of dimension at least ( 1 + ( n - 1 )*abs( incx ) ) pclange returns the value of the one norm, or the frobenius norm, or the infinity norm, or the element of largest absolute value of find max(abs(a(i,j))) find max(abs(a(i,j))) find max(abs(a(i,j))) find max(abs(a(i,j))) otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1 notes where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ) ssq will then satisfy m(j) = g(j-1) / abs(a(j,j) pcmax1 computes the global index of the maximum element in absolut in indx and the value is returned in amax, dimension of at least ( (jx-1)*m_x + ix + ( n - 1 )*abs( incx ) sub( x ). h22 = smalla(2,2,ki) if ( abs(h10) .le. max(ulp*(abs(h11)+abs(h22)) smalla(2,1,ki) = zero pdlange returns the value of the one norm, or the frobenius norm, or the infinity norm, or the element of largest absolute value of find max(abs(a(i,j))) find max(abs(a(i,j))) find max(abs(a(i,j))) do 20 k = i, l + 1, -1 tst1 = abs( h( k-1, k-1 ) ) + abs( h( k, k ) $ tst1 = dlanhs( '1', i-l+1, h( l, l ), ldh, work ) scl = max( scale, abs( x( i ) ) ) scale and sumsq must be supplied in scale and sumsq respectively. dimension of at least ( (jx-1)*m_x + ix + ( n - 1 )*abs( incx ) sub( x ). pdzsum1 returns the sum of absolute values of a comple pscsum1 returns the sum of absolute values of a comple h22 = smalla(2,2,ki) if ( abs(h10) .le. max(ulp*(abs(h11)+abs(h22)) smalla(2,1,ki) = zero pslange returns the value of the one norm, or the frobenius norm, or the infinity norm, or the element of largest absolute value of find max(abs(a(i,j))) find max(abs(a(i,j))) find max(abs(a(i,j))) do 20 k = i, l + 1, -1 tst1 = abs( h( k-1, k-1 ) ) + abs( h( k, k ) $ tst1 = slanhs( '1', i-l+1, h( l, l ), ldh, work ) scl = max( scale, abs( x( i ) ) ) scale and sumsq must be supplied in scale and sumsq respectively. dimension of at least ( (jx-1)*m_x + ix + ( n - 1 )*abs( incx ) sub( x ). dimension of at least ( (jx-1)*m_x + ix + ( n - 1 )*abs( incx ) sub( x ). pzlange returns the value of the one norm, or the frobenius norm, or the infinity norm, or the element of largest absolute value of find max(abs(a(i,j))) find max(abs(a(i,j))) find max(abs(a(i,j))) find max(abs(a(i,j))) otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1 notes where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ) ssq will then satisfy m(j) = g(j-1) / abs(a(j,j) pzmax1 computes the global index of the maximum element in absolut in indx and the value is returned in amax, x - real array of dimension at least ( 1 + ( n - 1 )*abs( incx ) ) s = abs( dble( h( i,i-1 ) ) ) + abs( dble( h( i-1,i-2 ) ) prepare to use wilkinson's shift. x - complex*16 array of dimension at least ( 1 + ( n - 1 )*abs( incx ) ) |
| absolute absolute ccombamax1 finds the element having maximum real part absolute each row and column of the distributed matrix b with elements b(i,j) = r(i) * a(i,j) * c(j) have absolute value 1 r(i) and c(j) are restricted to be between smlnum = smallest safe the absolute error tolerance for the eigenvalues when it is determined to lie in an interval [a,b] the absolute error tolerance for the eigenvalues when it is determined to lie in an interval [a,b] pclange returns the value of the one norm, or the frobenius norm, or the infinity norm, or the element of largest absolute value of amax (global input) real absolute value of largest distributed submatrix entry equed (global output) character amax (global input) real absolute value of the largest distributed submatrix entry equed (output) character*1 scale x so that its components are less than or equal to bignum in absolute value pcmax1 computes the global index of the maximum element in absolute in indx and the value is returned in amax, amax (global output) real absolute value of largest matrix element. if amax is ver should be scaled. each row and column of the distributed matrix b with elements b(i,j) = r(i) * a(i,j) * c(j) have absolute value 1 r(i) and c(j) are restricted to be between smlnum = smallest safe 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 pdlange returns the value of the one norm, or the frobenius norm, or the infinity norm, or the element of largest absolute value of matrix must be scaled so that its largest entry is no greater than overflow**(1/2) * underflow**(1/4) in absolute value than that. amax (global input) double precision absolute value of largest distributed submatrix entry equed (global output) character amax (global input) double precision absolute value of the largest distributed submatrix entry equed (output) character*1 amax (global output) double precision absolute value of largest matrix element. if amax is ver should be scaled. abstol (global input) double precision the absolute tolerance for the eigenvalues. an eigenvalu determined to lie in an interval whose width is abstol or the absolute error tolerance for the eigenvalues when it is determined to lie in an interval [a,b] the absolute error tolerance for the eigenvalues when it is determined to lie in an interval [a,b] pdzsum1 returns the sum of absolute values of a comple pscsum1 returns the sum of absolute values of a comple each row and column of the distributed matrix b with elements b(i,j) = r(i) * a(i,j) * c(j) have absolute value 1 r(i) and c(j) are restricted to be between smlnum = smallest safe 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 pslange returns the value of the one norm, or the frobenius norm, or the infinity norm, or the element of largest absolute value of matrix must be scaled so that its largest entry is no greater than overflow**(1/2) * underflow**(1/4) in absolute value than that. amax (global input) real absolute value of largest distributed submatrix entry equed (global output) character amax (global input) real absolute value of the largest distributed submatrix entry equed (output) character*1 amax (global output) real absolute value of largest matrix element. if amax is ver should be scaled. abstol (global input) real the absolute tolerance for the eigenvalues. an eigenvalu determined to lie in an interval whose width is abstol or the absolute error tolerance for the eigenvalues when it is determined to lie in an interval [a,b] the absolute error tolerance for the eigenvalues when it is determined to lie in an interval [a,b] each row and column of the distributed matrix b with elements b(i,j) = r(i) * a(i,j) * c(j) have absolute value 1 r(i) and c(j) are restricted to be between smlnum = smallest safe the absolute error tolerance for the eigenvalues when it is determined to lie in an interval [a,b] the absolute error tolerance for the eigenvalues when it is determined to lie in an interval [a,b] pzlange returns the value of the one norm, or the frobenius norm, or the infinity norm, or the element of largest absolute value of amax (global input) double precision absolute value of largest distributed submatrix entry equed (global output) character amax (global input) double precision absolute value of the largest distributed submatrix entry equed (output) character*1 scale x so that its components are less than or equal to bignum in absolute value pzmax1 computes the global index of the maximum element in absolute in indx and the value is returned in amax, amax (global output) double precision absolute value of largest matrix element. if amax is ver should be scaled. zcombamax1 finds the element having maximum real part absolute |
| ABSTOL ABSTOL ABSTOL (global input) rea the most orthogonal eigenvectors. ABSTOL (global input) rea the most orthogonal eigenvectors. eigenvalues are computed to highest accuracy ( this can be done by setting ABSTOL to the underflow threshold to psstebz ) ABSTOL (input) double precisio is narrower than abstol, or than reltol times the larger (in specifies the criterion for "convergence" of an interval. = 0 : when an interval is narrower than ABSTOL, or tha it is considered to have "converged". ABSTOL (global input) double precisio (or cluster) is considered to be located if it has been eigenvalues are computed to highest accuracy ( this can be done by setting ABSTOL to the underflow threshold to pdstebz ) ABSTOL (global input) double precisio the most orthogonal eigenvectors. ABSTOL (global input) double precisio the most orthogonal eigenvectors. ABSTOL (input) rea is narrower than abstol, or than reltol times the larger (in specifies the criterion for "convergence" of an interval. = 0 : when an interval is narrower than ABSTOL, or tha it is considered to have "converged". ABSTOL (global input) rea (or cluster) is considered to be located if it has been eigenvalues are computed to highest accuracy ( this can be done by setting ABSTOL to the underflow threshold to psstebz ) ABSTOL (global input) rea the most orthogonal eigenvectors. ABSTOL (global input) rea the most orthogonal eigenvectors. ABSTOL (global input) double precisio the most orthogonal eigenvectors. ABSTOL (global input) double precisio the most orthogonal eigenvectors. eigenvalues are computed to highest accuracy ( this can be done by setting ABSTOL to the underflow threshold to pdstebz ) |
| Accept Accept Accept iterate as jth eigenvector Accept iterate as jth eigenvector |
| acceptable acceptable 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) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol+3*nb) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) 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) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (nb+2*bw)*bw if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol + 3*nb) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) 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) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol+3*nb) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) 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) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (nb+2*bw)*bw if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol + 3*nb) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) 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) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol+3*nb) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) 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) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (nb+2*bw)*bw if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol + 3*nb) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) 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) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol+3*nb) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) 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) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (nb+2*bw)*bw if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) size of user-input workspace work. if lwork is too small, the minimal acceptable size will b (12*npcol + 3*nb) if laf is not large enough, an error code will be returned and the minimum acceptable size will be returned in af( 1 work (local workspace/local output) |
| accepted accepted the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to |
| acces acces if equed = 'r' or 'b', a(ia:ia+n-1,ja:ja+n-1) is multiplied on the left by diag(r); if equed='n' or 'c', r is not acces an output variable. if equed = 'r' or 'b', a(ia:ia+n-1,ja:ja+n-1) is multiplied on the left by diag(r); if equed='n' or 'c', r is not acces an output variable. if equed = 'r' or 'b', a(ia:ia+n-1,ja:ja+n-1) is multiplied on the left by diag(r); if equed='n' or 'c', r is not acces an output variable. if equed = 'r' or 'b', a(ia:ia+n-1,ja:ja+n-1) is multiplied on the left by diag(r); if equed='n' or 'c', r is not acces an output variable. |
| access access convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t convert descriptor into standard form for easy access t |
| accessed accessed this holds the size 3 reflectors one after another and this is only accessed when block is .true v2 this holds the size 3 reflectors one after another and this is only accessed when block is .true v2 on the right by diag(c); if equed = 'n' or 'r', c is not accessed. c is an input variable if fact = 'f'; otherwise 'b', each element of c must be positive. the scale factors for a distributed across process rows; not accessed if equed = 'n'. sr is an input variable i if fact = 'f' and equed = 'y', each element of sr must be on the right by diag(c); if equed = 'n' or 'r', c is not accessed. c is an input variable if fact = 'f'; otherwise 'b', each element of c must be positive. the scale factors for a distributed across process rows; not accessed if equed = 'n'. sr is an input variable i if fact = 'f' and equed = 'y', each element of sr must be on the right by diag(c); if equed = 'n' or 'r', c is not accessed. c is an input variable if fact = 'f'; otherwise 'b', each element of c must be positive. the scale factors for a distributed across process rows; not accessed if equed = 'n'. sr is an input variable i if fact = 'f' and equed = 'y', each element of sr must be on the right by diag(c); if equed = 'n' or 'r', c is not accessed. c is an input variable if fact = 'f'; otherwise 'b', each element of c must be positive. the scale factors for a distributed across process rows; not accessed if equed = 'n'. sr is an input variable i if fact = 'f' and equed = 'y', each element of sr must be this holds the size 3 reflectors one after another and this is only accessed when block is .true v2 this holds the size 3 reflectors one after another and this is only accessed when block is .true v2 |
| according according determine where the matrix splits and choose ql or qr iteration for each block, according to whether top or bottom diagona determine where the matrix splits and choose ql or qr iteration for each block, according to whether top or bottom diagona |
| Accuracy Accuracy by finding that eigenvalues were not identical across the process grid. in this case, the Accuracy o see "computing small singular values of bidiagonal matrices with guaranteed high relative Accuracy," by demmel an see "computing small singular values of bidiagonal matrices with guaranteed high relative Accuracy," by demmel an note : to obtain orthogonal vectors, it is best if
eigenvalues are computed to highest Accuracy ( this can b
slamch('u') --- abstol is an input parameter
than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest Accuracy, it should not be much smalle than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest Accuracy, it should not be much smalle entry is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest Accuracy, it should no note : to obtain orthogonal vectors, it is best if
eigenvalues are computed to highest Accuracy ( this can b
dlamch('u') --- abstol is an input parameter
by finding that eigenvalues were not identical across the process grid. in this case, the Accuracy o see "computing small singular values of bidiagonal matrices with guaranteed high relative Accuracy," by demmel an see "computing small singular values of bidiagonal matrices with guaranteed high relative Accuracy," by demmel an than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest Accuracy, it should not be much smalle than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest Accuracy, it should not be much smalle entry is no greater than overflow**(1/2) * underflow**(1/4) in absolute value, and for greatest Accuracy, it should no note : to obtain orthogonal vectors, it is best if
eigenvalues are computed to highest Accuracy ( this can b
slamch('u') --- abstol is an input parameter
by finding that eigenvalues were not identical across the process grid. in this case, the Accuracy o see "computing small singular values of bidiagonal matrices with guaranteed high relative Accuracy," by demmel an see "computing small singular values of bidiagonal matrices with guaranteed high relative Accuracy," by demmel an by finding that eigenvalues were not identical across the process grid. in this case, the Accuracy o see "computing small singular values of bidiagonal matrices with guaranteed high relative Accuracy," by demmel an see "computing small singular values of bidiagonal matrices with guaranteed high relative Accuracy," by demmel an note : to obtain orthogonal vectors, it is best if
eigenvalues are computed to highest Accuracy ( this can b
dlamch('u') --- abstol is an input parameter
|
| Accurate Accurate norm(inv(a)) computed in the code; if the estimate of norm(inv(a)) is Accurate, the error bound is guaranteed berr (local output) real array, dimension (loc(n_b)) norm(inv(a)) computed in the code; if the estimate of norm(inv(a)) is Accurate, the error bound is guaranteed berr (local output) double precision array, dimension (loc(n_b)) see w. kahan "Accurate eigenvalues of a symmetric tridiagona university, july 21, 1966. norm(inv(a)) computed in the code; if the estimate of norm(inv(a)) is Accurate, the error bound is guaranteed berr (local output) real array, dimension (loc(n_b)) see w. kahan "Accurate eigenvalues of a symmetric tridiagona university, july 21, 1966. norm(inv(a)) computed in the code; if the estimate of norm(inv(a)) is Accurate, the error bound is guaranteed berr (local output) double precision array, dimension (loc(n_b)) |
| accurately accurately eigenvalues will be computed most accurately when abstol i if this routine returns with ((mod(info,2).ne.0) .or. eigenvalues will be computed most accurately when abstol i if this routine returns with ((mod(info,2).ne.0) .or. 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 eigenvalues will be computed most accurately when abstol i if this routine returns with ((mod(info,2).ne.0) .or. eigenvalues will be computed most accurately when abstol i if this routine returns with ((mod(info,2).ne.0) .or. 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 eigenvalues will be computed most accurately when abstol i if this routine returns with ((mod(info,2).ne.0) .or. eigenvalues will be computed most accurately when abstol i if this routine returns with ((mod(info,2).ne.0) .or. eigenvalues will be computed most accurately when abstol i if this routine returns with ((mod(info,2).ne.0) .or. eigenvalues will be computed most accurately when abstol i if this routine returns with ((mod(info,2).ne.0) .or. |
| achieved achieved relationship between workspace, orthogonality & performance: greater performance can be achieved if adequate workspac performance can decrease as the workspace provided relationship between workspace, orthogonality & performance: greater performance can be achieved if adequate workspac performance can decrease as the workspace provided relationship between workspace, orthogonality & performance: greater performance can be achieved if adequate workspac performance can decrease as the workspace provided relationship between workspace, orthogonality & performance: greater performance can be achieved if adequate workspac performance can decrease as the workspace provided |
| ACM ACM a real or complex matrix, with applications to condition estimation", ACM trans. math. soft., vol. 14, no. 4, pp. 381-396, december 1988 ===================================================================== a real or complex matrix, with applications to condition estimation", ACM trans. math. soft., vol. 14, no. 4, pp. 381-396, december 1988 ===================================================================== a real or complex matrix, with applications to condition estimation", ACM trans. math. soft., vol. 14, no. 4, pp. 381-396, december 1988 ===================================================================== a real or complex matrix, with applications to condition estimation", ACM trans. math. soft., vol. 14, no. 4, pp. 381-396, december 1988 ===================================================================== |
| across across check consistency across processor check consistency across processor check consistency across processor check consistency across processor check consistency across processor scale factors for sub( a ). r is aligned with the distributed matrix a, and replicated across every process column. r i processes. analogously, ncvt is equal to the local number of columns of the matrix vt when distributed across procedure cbdsqr requires in its present form, pcheev assumes a homogeneous system and makes only spot checks of the consistency of the eigenvalues across th heterogeneous system may return incorrect results without any error arrays v and h are replicated across all processor columns local memory to an array of dimension (locc(ja+n-1)). on output, a is replicated across all processes i sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pivot vector may be distributed across a process ro matrix a. this routine will transpose the pivot vector if necessary. the row scale factors for sub( a ). r is aligned with the distributed matrix a, and replicated across every proces 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 check consistency across processor check consistency across processor for sub( a ). sr is aligned with the distributed matrix a, and replicated across every process column. sr is tied to th dimension (lld_a) the scale factors for a distributed across process rows fact = 'f'; otherwise, sr is an output variable. check consistency across processor check consistency across processor sstein2 ). on output, z is distributed across the p processes in bloc check consistency across processor check consistency across processor check consistency across processor check consistency across processor check consistency across processor scale factors for sub( a ). r is aligned with the distributed matrix a, and replicated across every process column. r i processes. analogously, ncvt is equal to the local number of columns of the matrix vt when distributed across procedure dbdsqr requires tridiagonal matrix. on output, q is distributed across the p processes in bloc local memory to an array of dimension (locc(ja+n-1)). on output, a is replicated across all processes i sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pivot vector may be distributed across a process ro matrix a. this routine will transpose the pivot vector if necessary. the row scale factors for sub( a ). r is aligned with the distributed matrix a, and replicated across every proces 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 it assumes that the input array, bycol, is distributed across bycol. the output array, byall, will be identical on all processes it assumes that the input array, byrow, is distributed across byrow. the output array, byall, will be identical on all processes check consistency across processor check consistency across processor for sub( a ). sr is aligned with the distributed matrix a, and replicated across every process column. sr is tied to th dimension (lld_a) the scale factors for a distributed across process rows fact = 'f'; otherwise, sr is an output variable. check consistency across processor check consistency across processor tridiagonal matrix. on output, q is distributed across the p processes in bloc dstein2 ). on output, z is distributed across the p processes in bloc in its present form, pdsyev assumes a homogeneous system and makes no checks for consistency of the eigenvalues or eigenvectors across heterogeneous system may return incorrect results without any error in its present form, pdsyevd assumes a homogeneous system and makes no checks for consistency of the eigenvalues or eigenvectors across heterogeneous system may return incorrect results without any error arrays v and h are replicated across all processor columns check consistency across processor check consistency across processor check consistency across processor check consistency across processor check consistency across processor scale factors for sub( a ). r is aligned with the distributed matrix a, and replicated across every process column. r i processes. analogously, ncvt is equal to the local number of columns of the matrix vt when distributed across procedure sbdsqr requires tridiagonal matrix. on output, q is distributed across the p processes in bloc local memory to an array of dimension (locc(ja+n-1)). on output, a is replicated across all processes i sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pivot vector may be distributed across a process ro matrix a. this routine will transpose the pivot vector if necessary. the row scale factors for sub( a ). r is aligned with the distributed matrix a, and replicated across every proces 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 it assumes that the input array, bycol, is distributed across bycol. the output array, byall, will be identical on all processes it assumes that the input array, byrow, is distributed across byrow. the output array, byall, will be identical on all processes check consistency across processor check consistency across processor for sub( a ). sr is aligned with the distributed matrix a, and replicated across every process column. sr is tied to th dimension (lld_a) the scale factors for a distributed across process rows fact = 'f'; otherwise, sr is an output variable. check consistency across processor check consistency across processor tridiagonal matrix. on output, q is distributed across the p processes in bloc sstein2 ). on output, z is distributed across the p processes in bloc in its present form, pssyev assumes a homogeneous system and makes no checks for consistency of the eigenvalues or eigenvectors across heterogeneous system may return incorrect results without any error in its present form, pssyevd assumes a homogeneous system and makes no checks for consistency of the eigenvalues or eigenvectors across heterogeneous system may return incorrect results without any error arrays v and h are replicated across all processor columns check consistency across processor check consistency across processor check consistency across processor check consistency across processor check consistency across processor scale factors for sub( a ). r is aligned with the distributed matrix a, and replicated across every process column. r i processes. analogously, ncvt is equal to the local number of columns of the matrix vt when distributed across procedure zbdsqr requires in its present form, pzheev assumes a homogeneous system and makes only spot checks of the consistency of the eigenvalues across th heterogeneous system may return incorrect results without any error arrays v and h are replicated across all processor columns local memory to an array of dimension (locc(ja+n-1)). on output, a is replicated across all processes i sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pivot vector may be distributed across a process ro matrix a. this routine will transpose the pivot vector if necessary. the row scale factors for sub( a ). r is aligned with the distributed matrix a, and replicated across every proces 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 check consistency across processor check consistency across processor for sub( a ). sr is aligned with the distributed matrix a, and replicated across every process column. sr is tied to th dimension (lld_a) the scale factors for a distributed across process rows fact = 'f'; otherwise, sr is an output variable. check consistency across processor check consistency across processor dstein2 ). on output, z is distributed across the p processes in bloc |
| active active the active part of the matrix is partitione a11 a12 a13 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. the active part of the matrix is partitione a11 a12 a13 the two integers npact (nu. of active processors) and npst loop. 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 two integers npact (nu. of active processors) and npst loop. 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 two integers npact (nu. of active processors) and npst loop. 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 two integers npact (nu. of active processors) and npst loop. 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 active part of the matrix is partitione a11 a12 a13 the active part of the matrix is partitione a11 a12 a13 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. |
| actual actual important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type m (global output) integer the actual number of eigenvalues found. 0 <= m <= n important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type m (global output) integer the actual number of eigenvalues found. 0 <= m <= n important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type important note: the actual blacs grid represented by th irrespective of which one-dimensional descriptor type |
| actually actually 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 m (global output) integer the number of columns in the arrays vl and/or vr actually is set to n. each selected eigenvector occupies one 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 isplit(nsplit-1)+1 through isplit(nsplit)=n. (only the first nsplit elements will actually be used, bu have, n words must be reserved for isplit.) 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 isplit(nsplit-1)+1 through isplit(nsplit)=n. (only the first nsplit elements will actually be used, bu have, n words must be reserved for isplit.) 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 m (global output) integer the number of columns in the arrays vl and/or vr actually is set to n. each selected eigenvector occupies one |
| Add Add if eigenvalues j and j-1 are too close, Add a relativel adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int if you want to guarantee orthogonality (at the cost of potentially poor performance) you should Add (clustersize-1)*n if you want to guarantee orthogonality (at the cost of potentially poor performance) you should Add (clustersize-1)*n adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int 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 adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int 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 if you want to guarantee orthogonality (at the cost of potentially poor performance) you should Add (clustersize-1)*n if you want to guarantee orthogonality (at the cost of potentially poor performance) you should Add (clustersize-1)*n adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int 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 adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int 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 if you want to guarantee orthogonality (at the cost of potentially poor performance) you should Add (clustersize-1)*n if you want to guarantee orthogonality (at the cost of potentially poor performance) you should Add (clustersize-1)*n adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int if you want to guarantee orthogonality (at the cost of potentially poor performance) you should Add (clustersize-1)*n if you want to guarantee orthogonality (at the cost of potentially poor performance) you should Add (clustersize-1)*n adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int adjust Addressing into matrix space to properly get int if eigenvalues j and j-1 are too close, Add a relativel |
| added added workspace needs are larger for pcheevx. liwork parameter added orfac, icluster() and gap() parameters added workspace needs are larger for pdsyevx. liwork parameter added orfac, icluster() and gap() parameters added workspace needs are larger for pssyevx. liwork parameter added orfac, icluster() and gap() parameters added workspace needs are larger for pzheevx. liwork parameter added orfac, icluster() and gap() parameters added |
| adding adding of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. scale x if necessary to avoid overflow when adding of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. scale x if necessary to avoid overflow when adding |
| addition addition one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. in addition, this routine performs a global minimization and maximi 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) one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. in addition, this routine performs a global minimization and maximi 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) one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. one-dimensional descriptors are a new addition to scalapack sinc arrays. |
| additional additional 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,*) 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,*) continue for additional iterations after norm reache ifail (output) integer array, dimension (n) ifail provides additional information when info .ne. the smallest minor which is not positive definite. dimension ( 2*desct(lld_) ) additional workspace may be required if pclattrs is update ifail (output) integer array, dimension (n) ifail provides additional information when info .ne. the smallest minor which is not positive definite. ifail (output) integer array, dimension (n) ifail provides additional information when info .ne. the smallest minor which is not positive definite. ifail (output) integer array, dimension (n) ifail provides additional information when info .ne. the smallest minor which is not positive definite. dimension ( 2*desct(lld_) ) additional workspace may be required if pzlattrs is update 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,*) continue for additional iterations after norm reache 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,*) |
| address address code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs if the matrix is hermitian, we address only a triangular portio can be obtained by adding along row i and column i of the the if the matrix is symmetric, we address only a triangular portio can be obtained by adding along row i and column i of the the code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs ===================================================================== code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs ===================================================================== code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs if the matrix is symmetric, we address only a triangular portio can be obtained by adding along row i and column i of the the code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs ===================================================================== code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs ===================================================================== code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs ===================================================================== code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs ===================================================================== code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs if the matrix is symmetric, we address only a triangular portio can be obtained by adding along row i and column i of the the code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs ===================================================================== code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs ===================================================================== code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs if the matrix is hermitian, we address only a triangular portio can be obtained by adding along row i and column i of the the if the matrix is symmetric, we address only a triangular portio can be obtained by adding along row i and column i of the the code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs code developer: andrew j. cleary, university of tennessee. current address: lawrence livermore national labs |
| addressing addressing adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int adjust addressing into matrix space to properly get int |
| adequate adequate dimension (lwork) work(1) returns workspace adequate workspace to allo codes (either the serial, chetrd, or the parallel code, pchettrd) when the workspace provided by the user is adequate relationship between workspace, orthogonality & performance: greater performance can be achieved if adequate workspac performance can decrease as the workspace provided relationship between workspace, orthogonality & performance: greater performance can be achieved if adequate workspac performance can decrease as the workspace provided codes (either the serial, dsytrd, or the parallel code, pdsyttrd) when the workspace provided by the user is adequate relationship between workspace, orthogonality & performance: greater performance can be achieved if adequate workspac performance can decrease as the workspace provided relationship between workspace, orthogonality & performance: greater performance can be achieved if adequate workspac performance can decrease as the workspace provided codes (either the serial, ssytrd, or the parallel code, pssyttrd) when the workspace provided by the user is adequate dimension (lwork) work(1) returns workspace adequate workspace to allo codes (either the serial, zhetrd, or the parallel code, pzhettrd) when the workspace provided by the user is adequate |
| Adjust Adjust Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int Adjust addressing into matrix space to properly get int |
| adjusted adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted form a new blacs grid (the "standard form" grid) with only procs holding part of the matrix, of size 1xnp where np is adjusted |
| adopted adopted distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, distributed are the individual vectors storing the diagonals, we have adopted the convention that both the p-by-1 descriptor an tridiagonal matrices. thus, for tridiagonal matrices, |
| affected affected ju is the index of the last column affected by the curren ju is the index of the last column affected by the curren ju is the index of the last column affected by the curren ju is the index of the last column affected by the curren |
| affects affects the appropriate slmake.inc file to include the compiler switch -dno_ieee. this switch only affects the compilation of pslaiect.c arguments the appropriate slmake.inc file to include the compiler switch -dno_ieee. this switch only affects the compilation of pdlaiect.c arguments the appropriate slmake.inc file to include the compiler switch -dno_ieee. this switch only affects the compilation of pslaiect.c arguments the appropriate slmake.inc file to include the compiler switch -dno_ieee. this switch only affects the compilation of pdlaiect.c arguments |
| AFL AFL copy matrix hu_i (the last bwl rows of gu_i) to AFL storag since we have gu_i stored, copy matrix hu_i (the last bwl rows of gu_i) to AFL storag since we have gu_i stored, copy matrix hu_i (the last bwl rows of gu_i) to AFL storag since we have gu_i stored, copy matrix hu_i (the last bwl rows of gu_i) to AFL storag since we have gu_i stored, |
| after after j2 and j3 are computed after ju has been updated factorize the current block of jb columns vecs (global input) complex array of size 3*n (matrix size) this holds the size 3 reflectors one after another and thi j2 and j3 are computed after ju has been updated factorize the current block of jb columns size) this holds the size 3 reflectors one after another and thi continue for additional iterations after norm reache pcdbtrf and this is stored in af. if a linear system is to be solved using pcdbtrs after the factorizatio pcdttrf and this is stored in af. if a linear system is to be solved using pcdttrs after the factorizatio this node stops work after this stage -- an extra cop look identical pcgbtrf and this is stored in af. if a linear system is to be solved using pcgbtrs after the factorizatio 2. if fact = 'n' or 'e', the lu decomposition is used to factor the matrix a (after equilibration if fact = 'e') a where p is a permutation matrix, l is a unit lower triangular > 0: if info = 1 through n, the i(th) eigenvalue did not converge in csteqr2 after a total of 30*n iterations by finding that eigenvalues were not identical across temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo is actually stored in one buffer buf where buf(istr1+1) starts the first buffer, buf(istr2+1) starts the second, etc.. after needs, they will be sent and received. then the next major key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th they are stored along a process column irsr0 : pointer to part of work used to store the rowsums after they are stored along a process column irsr0 : pointer to part of work used to store the rowsums after pcpbtrf and this is stored in af. if a linear system is to be solved using pcpbtrs after the factorizatio 2. if fact = 'n' or 'e', the cholesky decomposition is used to factor the matrix a (after equilibration if fact = 'e') a a = l * l**t, if uplo = 'l', pcpttrf and this is stored in af. if a linear system is to be solved using pcpttrs after the factorizatio specified eigenvalues. any vector which fails to converge is set to its current iterate after maxits iterations ( se on output, z is distributed across the p processes in block pddbtrf and this is stored in af. if a linear system is to be solved using pddbtrs after the factorizatio pddttrf and this is stored in af. if a linear system is to be solved using pddttrs after the factorizatio this node stops work after this stage -- an extra cop look identical pdgbtrf and this is stored in af. if a linear system is to be solved using pdgbtrs after the factorizatio 2. if fact = 'n' or 'e', the lu decomposition is used to factor the matrix a (after equilibration if fact = 'e') a where p is a permutation matrix, l is a unit lower triangular is actually stored in one buffer buf where buf(istr1+1) starts the first buffer, buf(istr2+1) starts the second, etc.. after needs, they will be sent and received. then the next major pdlaed1 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th they are stored along a process column irsr0 : pointer to part of work used to store the rowsums after pdpbtrf and this is stored in af. if a linear system is to be solved using pdpbtrs after the factorizatio 2. if fact = 'n' or 'e', the cholesky decomposition is used to factor the matrix a (after equilibration if fact = 'e') a a = l * l**t, if uplo = 'l', pdpttrf and this is stored in af. if a linear system is to be solved using pdpttrs after the factorizatio specified eigenvalues. any vector which fails to converge is set to its current iterate after maxits iterations ( se on output, z is distributed across the p processes in block > 0: if info = 1 through n, the i(th) eigenvalue did not converge in dsteqr2 after a total of 30*n iterations by finding that eigenvalues were not identical across temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo pjlaenv is patterned after ilaenv and keeps the same interface i used at present in scalapack. most scalapack codes use the input psdbtrf and this is stored in af. if a linear system is to be solved using psdbtrs after the factorizatio psdttrf and this is stored in af. if a linear system is to be solved using psdttrs after the factorizatio this node stops work after this stage -- an extra cop look identical psgbtrf and this is stored in af. if a linear system is to be solved using psgbtrs after the factorizatio 2. if fact = 'n' or 'e', the lu decomposition is used to factor the matrix a (after equilibration if fact = 'e') a where p is a permutation matrix, l is a unit lower triangular is actually stored in one buffer buf where buf(istr1+1) starts the first buffer, buf(istr2+1) starts the second, etc.. after needs, they will be sent and received. then the next major pslaed1 computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th they are stored along a process column irsr0 : pointer to part of work used to store the rowsums after pspbtrf and this is stored in af. if a linear system is to be solved using pspbtrs after the factorizatio 2. if fact = 'n' or 'e', the cholesky decomposition is used to factor the matrix a (after equilibration if fact = 'e') a a = l * l**t, if uplo = 'l', pspttrf and this is stored in af. if a linear system is to be solved using pspttrs after the factorizatio specified eigenvalues. any vector which fails to converge is set to its current iterate after maxits iterations ( se on output, z is distributed across the p processes in block > 0: if info = 1 through n, the i(th) eigenvalue did not converge in ssteqr2 after a total of 30*n iterations by finding that eigenvalues were not identical across temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo pzdbtrf and this is stored in af. if a linear system is to be solved using pzdbtrs after the factorizatio pzdttrf and this is stored in af. if a linear system is to be solved using pzdttrs after the factorizatio this node stops work after this stage -- an extra cop look identical pzgbtrf and this is stored in af. if a linear system is to be solved using pzgbtrs after the factorizatio 2. if fact = 'n' or 'e', the lu decomposition is used to factor the matrix a (after equilibration if fact = 'e') a where p is a permutation matrix, l is a unit lower triangular > 0: if info = 1 through n, the i(th) eigenvalue did not converge in zsteqr2 after a total of 30*n iterations by finding that eigenvalues were not identical across temporary variables. the following variables are used within a few lines after they are set and do hold state from one loo is actually stored in one buffer buf where buf(istr1+1) starts the first buffer, buf(istr2+1) starts the second, etc.. after needs, they will be sent and received. then the next major key (global input) integer array, dimension( n ) indicates the actual index (after sorting) for each of th they are stored along a process column irsr0 : pointer to part of work used to store the rowsums after they are stored along a process column irsr0 : pointer to part of work used to store the rowsums after pzpbtrf and this is stored in af. if a linear system is to be solved using pzpbtrs after the factorizatio 2. if fact = 'n' or 'e', the cholesky decomposition is used to factor the matrix a (after equilibration if fact = 'e') a a = l * l**t, if uplo = 'l', pzpttrf and this is stored in af. if a linear system is to be solved using pzpttrs after the factorizatio specified eigenvalues. any vector which fails to converge is set to its current iterate after maxits iterations ( se on output, z is distributed across the p processes in block j2 and j3 are computed after ju has been updated factorize the current block of jb columns size) this holds the size 3 reflectors one after another and thi continue for additional iterations after norm reache j2 and j3 are computed after ju has been updated factorize the current block of jb columns vecs (global input) complex*16 array of size 3*n (matrix size) this holds the size 3 reflectors one after another and thi |
| AFU AFU copy matrix hl_i (the last bwu rows of gl_i^c) to AFU stor since we have gl_i^c stored, copy matrix hl_i (the last bwu rows of gl_i^t) to AFU stor since we have gl_i^t stored, copy matrix hl_i (the last bwu rows of gl_i^t) to AFU stor since we have gl_i^t stored, copy matrix hl_i (the last bwu rows of gl_i^c) to AFU stor since we have gl_i^c stored, |
| again again whether x should be overwritten by a * x or a' * x. on the final return from pclacon, kase will again be 0 further details ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. we first hit a border when mod(k1(ki)-1,hbl)=hbl-2 and we hit it again when mod(k1(ki)-1,hbl)=hbl-1 note : if the eigenvectors obtained are not orthogonal, increase lwork and run the code again notes whether x should be overwritten by a * x or a' * x. on the final return from pdlacon, kase will again be 0 further details ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. we first hit a border when mod(k1(ki)-1,hbl)=hbl-2 and we hit it again when mod(k1(ki)-1,hbl)=hbl-1 cure: increase the parameter "fudge", recompile, and try again internal parameters note : if the eigenvectors obtained are not orthogonal, increase lwork and run the code again notes whether x should be overwritten by a * x or a' * x. on the final return from pslacon, kase will again be 0 further details ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. we first hit a border when mod(k1(ki)-1,hbl)=hbl-2 and we hit it again when mod(k1(ki)-1,hbl)=hbl-1 cure: increase the parameter "fudge", recompile, and try again internal parameters note : if the eigenvectors obtained are not orthogonal, increase lwork and run the code again notes whether x should be overwritten by a * x or a' * x. on the final return from pzlacon, kase will again be 0 further details ii (global input) integer by using rev 0 & 1, data can be sent out and returned again receiving the replicated b. we first hit a border when mod(k1(ki)-1,hbl)=hbl-2 and we hit it again when mod(k1(ki)-1,hbl)=hbl-1 note : if the eigenvectors obtained are not orthogonal, increase lwork and run the code again notes |
| against against substitution. it is the hope that scaling would be used to make the the code robust against possible overflow. but scaling has not ye the triangular systems. pclattrs just calls pctrsv. substitution. it is the hope that scaling would be used to make the the code robust against possible overflow. but scaling has not ye the triangular systems. pzlattrs just calls pztrsv. |
| aimag aimag scl = max( scale, abs( real( x( i ) ) ), abs( aimag( x( i ) ) ) ) scl = max( scale, abs( real( x( i ) ) ), abs( aimag( x( i ) ) ) ) |
| algorithm algorithm this is the unblocked version of the algorithm, calling level 2 blas arguments this is the unblocked version of the algorithm, calling level 2 blas arguments the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. this is the right-looking parallel level 2 blas version of the algorithm notes this is the right-looking parallel level 3 blas version of the algorithm notes pcheevd computes all the eigenvalues and eigenvectors of a hermitian matrix a by using a divide and conquer algorithm arguments necessary to scan the "tridiagonal portion of the matrix." in the lapack algorithm zlahqr, a loop of m goes from i-2 down t h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and this is the unblocked form of the algorithm, calling level 2 blas on should be strictly local to one process. this is the blocked form of the algorithm, calling level 3 pblas notes the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the algorithm used in this program is basically backward (forward the code robust against possible overflow. but scaling has not yet the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. this is the right-looking parallel level 2 blas version of the algorithm notes this is the right-looking parallel level 3 blas version of the algorithm notes necessary to scan the "tridiagonal portion of the matrix." in the lapack algorithm dlahqr, a loop of m goes from i-2 down t h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and info = -i. > 0: the algorithm failed to compute the info/(n+1) t global rows and columns mod(info,n+1). the eigenvectors of the original matrix are stored in q, and the eigenvalues are in d. the algorithm consists of three stages the first stage consists of deflating the size of the problem < 0: if info = -i, the i-th argument had an illegal value. > 0: the algorithm failed to compute the ith eigenvalue ===================================================================== this is the unblocked form of the algorithm, calling level 2 blas on should be strictly local to one process. this is the blocked form of the algorithm, calling level 3 pblas notes the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . symmetric tridiagonal matrix in parallel, using the divide and conquer algorithm this code makes very mild assumptions about floating point info = -i. > 0: the algorithm failed to compute the info/(n+1) t global rows and columns mod(info,n+1). the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. this is the right-looking parallel level 2 blas version of the algorithm notes this is the right-looking parallel level 3 blas version of the algorithm notes necessary to scan the "tridiagonal portion of the matrix." in the lapack algorithm dlahqr, a loop of m goes from i-2 down t h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and info = -i. > 0: the algorithm failed to compute the info/(n+1) t global rows and columns mod(info,n+1). the eigenvectors of the original matrix are stored in q, and the eigenvalues are in d. the algorithm consists of three stages the first stage consists of deflating the size of the problem < 0: if info = -i, the i-th argument had an illegal value. > 0: the algorithm failed to compute the ith eigenvalue ===================================================================== this is the unblocked form of the algorithm, calling level 2 blas on should be strictly local to one process. this is the blocked form of the algorithm, calling level 3 pblas notes the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . symmetric tridiagonal matrix in parallel, using the divide and conquer algorithm this code makes very mild assumptions about floating point info = -i. > 0: the algorithm failed to compute the info/(n+1) t global rows and columns mod(info,n+1). the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. this is the right-looking parallel level 2 blas version of the algorithm notes this is the right-looking parallel level 3 blas version of the algorithm notes pzheevd computes all the eigenvalues and eigenvectors of a hermitian matrix a by using a divide and conquer algorithm arguments necessary to scan the "tridiagonal portion of the matrix." in the lapack algorithm zlahqr, a loop of m goes from i-2 down t h(m,m),h(m+1,m+1),h(m+1,m),h(m,m+1),h(m-1,m-1),h(m,m-1), and this is the unblocked form of the algorithm, calling level 2 blas on should be strictly local to one process. this is the blocked form of the algorithm, calling level 3 pblas notes the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. off-diagonal block needed on neighboring processor to start algorithm the mapping for matrices must be blocked, reflecting the nature of the divide and conquer algorithm as a task-parallel algorithm chunk of the matrix. ******************************************************************* .. begin reduced system phase of algorithm . the algorithm used in this program is basically backward (forward the code robust against possible overflow. but scaling has not yet this is the unblocked version of the algorithm, calling level 2 blas arguments this is the unblocked version of the algorithm, calling level 2 blas arguments |
| algorithmic algorithmic = 2: the panel blocking factor; = 3: the algorithmic blocking factor = 5: maximum size for direct call to the lapack routine |
| algorithms algorithms depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. depends on a variety of parameters, especially the bandwidth. currently, only algorithms designed for the case n/p >> bw ar partitioning, domain decomposition-type, etc. |
| align align 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 |
| aligned aligned on entry, the local matrix to apply the shifts on. h should be aligned so that the starting row is 2 on entry, the local matrix to apply the shifts on. h should be aligned so that the starting row is 2 matrix. globally, dl(1) is not referenced, and dl must be aligned with d on exit, this array contains information containing the matrix. globally, dl(1) is not referenced, and dl must be aligned with d on exit, this array contains information containing the if info = 0 or info > ia+m-1, r(ia:ia+m-1) contains the row scale factors for sub( a ). r is aligned with the distribute tied to the distributed matrix a. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), pcgetrf; ipiv(i) -> the global row local row i was swapped with. this array must be aligned wit a. reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, thi 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. sr (local input) real array, dimension locr(m_a) the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligned process column. sr is tied to the distributed matrix a. if info = 0, sr(ia:ia+n-1) contains the row scale factors for sub( a ). sr is aligned with the distributed matrix a distributed matrix a. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. distributed the same way on the same processes. these conditions ensure that sub( x ) and sub( b ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), matrix. globally, dl(1) is not referenced, and dl must be aligned with d on exit, this array contains information containing the matrix. globally, dl(1) is not referenced, and dl must be aligned with d on exit, this array contains information containing the if info = 0 or info > ia+m-1, r(ia:ia+m-1) contains the row scale factors for sub( a ). r is aligned with the distribute tied to the distributed matrix a. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), pdgetrf; ipiv(i) -> the global row local row i was swapped with. this array must be aligned wit reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, this informatio 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. sr (local input) double precision array, dimension locr(m_a) the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligned process column. sr is tied to the distributed matrix a. if info = 0, sr(ia:ia+n-1) contains the row scale factors for sub( a ). sr is aligned with the distributed matrix a distributed matrix a. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. distributed the same way on the same processes. these conditions ensure that sub( x ) and sub( b ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), matrix. globally, dl(1) is not referenced, and dl must be aligned with d on exit, this array contains information containing the matrix. globally, dl(1) is not referenced, and dl must be aligned with d on exit, this array contains information containing the if info = 0 or info > ia+m-1, r(ia:ia+m-1) contains the row scale factors for sub( a ). r is aligned with the distribute tied to the distributed matrix a. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), psgetrf; ipiv(i) -> the global row local row i was swapped with. this array must be aligned wit reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, this informatio 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. sr (local input) real array, dimension locr(m_a) the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligned process column. sr is tied to the distributed matrix a. if info = 0, sr(ia:ia+n-1) contains the row scale factors for sub( a ). sr is aligned with the distributed matrix a distributed matrix a. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. distributed the same way on the same processes. these conditions ensure that sub( x ) and sub( b ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), matrix. globally, dl(1) is not referenced, and dl must be aligned with d on exit, this array contains information containing the matrix. globally, dl(1) is not referenced, and dl must be aligned with d on exit, this array contains information containing the if info = 0 or info > ia+m-1, r(ia:ia+m-1) contains the row scale factors for sub( a ). r is aligned with the distribute tied to the distributed matrix a. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), pzgetrf; ipiv(i) -> the global row local row i was swapped with. this array must be aligned wit a. reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, thi 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. sr (local input) double precision array, dimension locr(m_a) the scale factors for a(ia:ia+m-1,ja:ja+n-1). sr is aligned process column. sr is tied to the distributed matrix a. if info = 0, sr(ia:ia+n-1) contains the row scale factors for sub( a ). sr is aligned with the distributed matrix a distributed matrix a. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. matrix. globally, du(n) is not referenced, and du must be aligned with d factors of the matrix. distributed the same way on the same processes. these conditions ensure that sub( x ) and sub( b ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), on entry, the local matrix to apply the shifts on. h should be aligned so that the starting row is 2 on entry, the local matrix to apply the shifts on. h should be aligned so that the starting row is 2 |
| Alignment Alignment ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication ===================================================================== Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication ===================================================================== Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove ja = ib Alignment restriction that prevents unnecessary communication ja = ib Alignment restriction that prevents unnecessary communication these are Alignment restrictions that may or may not be remove Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement Alignment requirement |
| all all clamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges dlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges skip all the work if the block size is one where a(1:n, ja:ja+n-1) is an n-by-n complex banded diagonally dominant-like distribute a(1:n, ja:ja+n-1) is an n-by-n complex banded diagonally dominant-like distribute where a(1:n, ja:ja+n-1) is an n-by-n complex tridiagonal diagonally dominant-like distribute a(1:n, ja:ja+n-1) is an n-by-n complex tridiagonal diagonally dominant-like distribute 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 routine pcgbtrf must be called first ===================================================================== its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side vectors b and solution vectors x can be handled in a single call the n-by-nrhs right hand side matrix sub( b ) and the m-by-nrhs its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pcheev computes selected eigenvalues and, optionally, eigenvector of scalapack routines. pcheevd computes all the eigenvalues and eigenvectors of a hermitia pcheevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by pchegvx computes all the eigenvalues, and optionally of a complex generalized hermitian-definite eigenproblem, of the form pchengst calls pchegst when uplo='u', hence pchengst provide support for uplo='u' is limited to calling the old, slow, pchetr its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), of its process row. the values of locp() and locq() may be determined via a call t locp( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pclaconsb looks for two consecutive small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a pclacp2 copies all or part of a distributed matrix a to anothe performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pclacp3 is an auxiliary routine that copies from a global paralle the entire submatrix that is copied gets placed on one node or pclacpy copies all or part of a distributed matrix a to anothe performs a local copy sub( a ) := sub( b ), where sub( a ) denotes itn is the total number of qr iterations allowed this is an auxiliary routine called by pchetrd to redistribute d, pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. similarly all process columns for column pivoting. if the elements of sub( x ) are all zero and x(iax,jax) is real its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pclasmsub looks for a small subdiagonal element from the botto 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 routine pcpbtrf must be called first ===================================================================== its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), part of global vector storing the upper diagonal of the matrix. globally, du(n) is not referenced, and du must b on exit, this array contains information containing the routine pcpttrf must be called first ===================================================================== pcstein computes the eigenvectors of a symmetric tridiagonal matrix in parallel, using inverse iteration. the eigenvectors foun orthogonalize vectors that are on different processes. the extent its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pctrevc computes some or all of the right and/or left eigenvectors o its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), where a(1:n, ja:ja+n-1) is an n-by-n real banded diagonally dominant-like distribute a(1:n, ja:ja+n-1) is an n-by-n real banded diagonally dominant-like distribute where a(1:n, ja:ja+n-1) is an n-by-n real tridiagonal diagonally dominant-like distribute a(1:n, ja:ja+n-1) is an n-by-n real tridiagonal diagonally dominant-like distribute 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 routine pdgbtrf must be called first ===================================================================== its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side vectors b and solution vectors x can be handled in a single call the n-by-nrhs right hand side matrix sub( b ) and the m-by-nrhs its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pdlaconsb looks for two consecutive small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a pdlacp2 copies all or part of a distributed matrix a to anothe performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pdlacp3 is an auxiliary routine that copies from a global paralle the entire submatrix that is copied gets placed on one node or pdlacpy copies all or part of a distributed matrix a to anothe performs a local copy sub( a ) := sub( b ), where sub( a ) denotes magnitude) endpoint, then it is considered to be sufficiently small, i.e., converged pdlaecv modifies kf to be the index of the last converged interval, i.e., on output, all intervals [ intvl(2*i-1), intvl(2*i) ], i < kf pdlaecv. pdlaed0 computes all eigenvalues and corresponding eigenvectors of itn is the total number of qr iterations allowed this is an auxiliary routine called by pdsytrd to redistribute d, pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. similarly all process columns for column pivoting. it assumes that the input array, bycol, is distributed across rows and that all process columns contain the same copy o and will contain the entire array. it assumes that the input array, byrow, is distributed across columns and that all process rows contain the same copy o and will contain the entire array. if the elements of sub( x ) are all zero, then tau = 0 and h i its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pdlasmsub looks for a small subdiagonal element from the botto its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), 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 routine pdpbtrf must be called first ===================================================================== its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), part of global vector storing the upper diagonal of the matrix. globally, du(n) is not referenced, and du must b on exit, this array contains information containing the routine pdpttrf must be called first ===================================================================== pdstebz computes the eigenvalues of a symmetric tridiagonal matrix in parallel. the user may ask for all eigenvalues, all eigenvalues i static partitioning of work is done at the beginning of pdstebz which ======= pdstedc computes all eigenvalues and eigenvectors of conquer algorithm. pdstein computes the eigenvectors of a symmetric tridiagonal matrix in parallel, using inverse iteration. the eigenvectors foun orthogonalize vectors that are on different processes. the extent pdsyev computes all eigenvalues and, optionally, eigenvector of scalapack routines. pdsyevd computes all the eigenvalues and eigenvector of scalapack routines. pdsyevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by pdsygvx computes all the eigenvalues, and optionally of a real generalized sy-definite eigenproblem, of the form pdsyngst calls pdhegst when uplo='u', hence pdhengst provide support for uplo='u' is limited to calling the old, slow, pdsytr its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), of its process row. the values of locp() and locq() may be determined via a call t locp( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pjlaenv is called from the scalapack symmetric and hermitia problem-dependent parameters for the local environment. see ispec where a(1:n, ja:ja+n-1) is an n-by-n real banded diagonally dominant-like distribute a(1:n, ja:ja+n-1) is an n-by-n real banded diagonally dominant-like distribute where a(1:n, ja:ja+n-1) is an n-by-n real tridiagonal diagonally dominant-like distribute a(1:n, ja:ja+n-1) is an n-by-n real tridiagonal diagonally dominant-like distribute 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 routine psgbtrf must be called first ===================================================================== its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side vectors b and solution vectors x can be handled in a single call the n-by-nrhs right hand side matrix sub( b ) and the m-by-nrhs its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pslaconsb looks for two consecutive small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a pslacp2 copies all or part of a distributed matrix a to anothe performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pslacp3 is an auxiliary routine that copies from a global paralle the entire submatrix that is copied gets placed on one node or pslacpy copies all or part of a distributed matrix a to anothe performs a local copy sub( a ) := sub( b ), where sub( a ) denotes magnitude) endpoint, then it is considered to be sufficiently small, i.e., converged pslaecv modifies kf to be the index of the last converged interval, i.e., on output, all intervals [ intvl(2*i-1), intvl(2*i) ], i < kf pslaecv. pslaed0 computes all eigenvalues and corresponding eigenvectors of itn is the total number of qr iterations allowed this is an auxiliary routine called by pssytrd to redistribute d, pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. similarly all process columns for column pivoting. it assumes that the input array, bycol, is distributed across rows and that all process columns contain the same copy o and will contain the entire array. it assumes that the input array, byrow, is distributed across columns and that all process rows contain the same copy o and will contain the entire array. if the elements of sub( x ) are all zero, then tau = 0 and h i its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pslasmsub looks for a small subdiagonal element from the botto its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), 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 routine pspbtrf must be called first ===================================================================== its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), part of global vector storing the upper diagonal of the matrix. globally, du(n) is not referenced, and du must b on exit, this array contains information containing the routine pspttrf must be called first ===================================================================== psstebz computes the eigenvalues of a symmetric tridiagonal matrix in parallel. the user may ask for all eigenvalues, all eigenvalues i static partitioning of work is done at the beginning of psstebz which ======= psstedc computes all eigenvalues and eigenvectors of conquer algorithm. psstein computes the eigenvectors of a symmetric tridiagonal matrix in parallel, using inverse iteration. the eigenvectors foun orthogonalize vectors that are on different processes. the extent pssyev computes all eigenvalues and, optionally, eigenvector of scalapack routines. pssyevd computes all the eigenvalues and eigenvector of scalapack routines. pssyevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by pssygvx computes all the eigenvalues, and optionally of a real generalized sy-definite eigenproblem, of the form pssyngst calls pshegst when uplo='u', hence pshengst provide support for uplo='u' is limited to calling the old, slow, pssytr its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), of its process row. the values of locp() and locq() may be determined via a call t locp( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), where a(1:n, ja:ja+n-1) is an n-by-n complex banded diagonally dominant-like distribute a(1:n, ja:ja+n-1) is an n-by-n complex banded diagonally dominant-like distribute where a(1:n, ja:ja+n-1) is an n-by-n complex tridiagonal diagonally dominant-like distribute a(1:n, ja:ja+n-1) is an n-by-n complex tridiagonal diagonally dominant-like distribute 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 routine pzgbtrf must be called first ===================================================================== its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), and b( ib:ib+n-1, jb:jb+nrhs-1 ) otherwise. several right hand side vectors b and solution vectors x can be handled in a single call the n-by-nrhs right hand side matrix sub( b ) and the m-by-nrhs its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pzheev computes selected eigenvalues and, optionally, eigenvector of scalapack routines. pzheevd computes all the eigenvalues and eigenvectors of a hermitia pzheevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by pzhegvx computes all the eigenvalues, and optionally of a complex generalized hermitian-definite eigenproblem, of the form pzhengst calls pzhegst when uplo='u', hence pzhengst provide support for uplo='u' is limited to calling the old, slow, pzhetr its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), of its process row. the values of locp() and locq() may be determined via a call t locp( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pzlaconsb looks for two consecutive small subdiagonal elements b given by h44, h33, & h43h34 and see if this would make a pzlacp2 copies all or part of a distributed matrix a to anothe performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pzlacp3 is an auxiliary routine that copies from a global paralle the entire submatrix that is copied gets placed on one node or pzlacpy copies all or part of a distributed matrix a to anothe performs a local copy sub( a ) := sub( b ), where sub( a ) denotes itn is the total number of qr iterations allowed this is an auxiliary routine called by pzhetrd to redistribute d, pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. similarly all process columns for column pivoting. if the elements of sub( x ) are all zero and x(iax,jax) is real its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pzlasmsub looks for a small subdiagonal element from the botto 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 routine pzpbtrf must be called first ===================================================================== its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), the diagonal. this choice of sr and sc puts the condition number of b within a factor n of the smallest possible condition numbe its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), part of global vector storing the upper diagonal of the matrix. globally, du(n) is not referenced, and du must b on exit, this array contains information containing the routine pzpttrf must be called first ===================================================================== pzstein computes the eigenvectors of a symmetric tridiagonal matrix in parallel, using inverse iteration. the eigenvectors foun orthogonalize vectors that are on different processes. the extent its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), pztrevc computes some or all of the right and/or left eigenvectors o its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), its process row. the values of locr() and locc() may be determined via a call to th locr( m ) = numroc( m, mb_a, myrow, rsrc_a, nprow ), slamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges skip all the work if the block size is one zlamsh sends multiple shifts through a small (single node) matrix t subsequent shifts in an effort to maximize the number of bulges |
| allocated allocated processes and then calls sstein2 (modified lapack routine) on each individual process. if insufficient workspace is allocated, th processes and then calls dstein2 (modified lapack routine) on each individual process. if insufficient workspace is allocated, th processes and then calls sstein2 (modified lapack routine) on each individual process. if insufficient workspace is allocated, th processes and then calls dstein2 (modified lapack routine) on each individual process. if insufficient workspace is allocated, th |
| allocation allocation eigenvectors that are to be orthogonalized are computed by the same process. pcstein decides on the allocation of work among th individual process. if insufficient workspace is allocated, the eigenvectors that are to be orthogonalized are computed by the same process. pdstein decides on the allocation of work among th individual process. if insufficient workspace is allocated, the eigenvectors that are to be orthogonalized are computed by the same process. psstein decides on the allocation of work among th individual process. if insufficient workspace is allocated, the eigenvectors that are to be orthogonalized are computed by the same process. pzstein decides on the allocation of work among th individual process. if insufficient workspace is allocated, the |
| allow allow since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is dimension (lwork) work(1) returns workspace adequate workspace to allow at present, scale is always returned as 1.0, it is returned here to allow for future enhancement info (global output) integer the eigenvalues are computed. therefore, when range='v' and as long as lrwork is large enough to allow pchegvx t eigenvalues and as many eigenvectors as it can. at present, scale is always returned as 1.0, it is returned here to allow for future enhancement work (local workspace/local output) complex array, since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is the eigenvalues are computed. therefore, when range='v' and as long as lwork is large enough to allow pdsyevx t eigenvalues and as many eigenvectors as it can. at present, scale is always returned as 1.0, it is returned here to allow for future enhancement info (global output) integer the eigenvalues are computed. therefore, when range='v' and as long as lwork is large enough to allow pdsygvx t eigenvalues and as many eigenvectors as it can. at present, scale is always returned as 1.0, it is returned here to allow for future enhancement work (local workspace/local output) double precision array, since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is the eigenvalues are computed. therefore, when range='v' and as long as lwork is large enough to allow pssyevx t eigenvalues and as many eigenvectors as it can. at present, scale is always returned as 1.0, it is returned here to allow for future enhancement info (global output) integer the eigenvalues are computed. therefore, when range='v' and as long as lwork is large enough to allow pssygvx t eigenvalues and as many eigenvectors as it can. at present, scale is always returned as 1.0, it is returned here to allow for future enhancement work (local workspace/local output) real array, since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is dimension (lwork) work(1) returns workspace adequate workspace to allow at present, scale is always returned as 1.0, it is returned here to allow for future enhancement info (global output) integer the eigenvalues are computed. therefore, when range='v' and as long as lrwork is large enough to allow pzhegvx t eigenvalues and as many eigenvectors as it can. at present, scale is always returned as 1.0, it is returned here to allow for future enhancement work (local workspace/local output) complex*16 array, since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is since scalapack supports two-dimensional arrays as the fundamental object, we allow 1d arrays to be distributed either over th 2nd dimension (as if the grid were 1-by-p). this choice is |
| allowed allowed itn is the total number of qr iterations allowed summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowed documented below. (search for "restrictions".) itn is the total number of qr iterations allowed summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 itn is the total number of qr iterations allowed summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowed documented below. (search for "restrictions".) this routine will not function correctly if it is converted to all lower case. converting it to all upper case is allowed arguments summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 itn is the total number of qr iterations allowed summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowed documented below. (search for "restrictions".) summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowed documented below. (search for "restrictions".) itn is the total number of qr iterations allowed summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 summary of allowed descriptors, types, and blacs grids blacs grid 1xp or px1 1xp or px1 1xp px1 have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably have adopted the convention that both the p-by-1 descriptor and the 1-by-p descriptor are allowed and are equivalent fo dtype_a = 501 or 502 can be used interchangeably itn is the total number of qr iterations allowed |
| allows allows v = tau * ( v - c * tau' * h / 2 ) the above formula allows tau to be spread down in th v = tau * ( v - c * tau' * h / 2 ) the above formula allows tau to be spread down in th v = tau * ( v - c * tau' * h / 2 ) the above formula allows tau to be spread down in th v = tau * ( v - c * tau' * h / 2 ) the above formula allows tau to be spread down in th |
| almost almost the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error in x(j). the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of th aligned with the matrices b and x. pchentrd is faster than pchetrd on almost all matrices enough workspace is available to use the tailored codes. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error largest entry in sub( x ). the estimate is as reliable as the estimate for rcond, and is almost always a sligh this array is tied to the distributed matrix x. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error in x(j). the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of th aligned with the matrices b and x. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error static partitioning of work is done at the beginning of pdstebz which results in all processes finding an (almost) equal number o pdsyntrd is faster than pdsytrd on almost all matrices enough workspace is available to use the tailored codes. 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. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error in x(j). the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of th aligned with the matrices b and x. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error static partitioning of work is done at the beginning of psstebz which results in all processes finding an (almost) equal number o pssyntrd is faster than pssytrd on almost all matrices enough workspace is available to use the tailored codes. 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. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error in x(j). the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of th aligned with the matrices b and x. pzhentrd is faster than pzhetrd on almost all matrices enough workspace is available to use the tailored codes. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error largest entry in sub( x ). the estimate is as reliable as the estimate for rcond, and is almost always a sligh this array is tied to the distributed matrix x. |
| along along of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. pivot vector should be aligned with the distributed matrix a. for pivoting the rows of sub( a ), ipiv should be distributed along ipiv should be distributed along a process row and replicated over the result are only available in the scope of sub( x ), i.e if sub( x ) is distributed along a process row, the correct results ar is distributed along a process column, the correct results are only sub( a ). this routine assumes that the pivoting information has already been broadcast along the process row or column same mb (or nb) block. if you want to pivot a full matrix, use the scaling factor are stored along process rows in sr and alon greatly the application of the factors. of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. pivot vector should be aligned with the distributed matrix a. for pivoting the rows of sub( a ), ipiv should be distributed along ipiv should be distributed along a process row and replicated over the result are only available in the scope of sub( x ), i.e if sub( x ) is distributed along a process row, the correct results ar is distributed along a process column, the correct results are only sub( a ). this routine assumes that the pivoting information has already been broadcast along the process row or column same mb (or nb) block. if you want to pivot a full matrix, use the scaling factor are stored along process rows in sr and alon greatly the application of the factors. of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. pivot vector should be aligned with the distributed matrix a. for pivoting the rows of sub( a ), ipiv should be distributed along ipiv should be distributed along a process row and replicated over the result are only available in the scope of sub( x ), i.e if sub( x ) is distributed along a process row, the correct results ar is distributed along a process column, the correct results are only sub( a ). this routine assumes that the pivoting information has already been broadcast along the process row or column same mb (or nb) block. if you want to pivot a full matrix, use the scaling factor are stored along process rows in sr and alon greatly the application of the factors. of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. of the matrix. a sum of row (column) i of the complete matrix can be obtained by adding along row i and column i of the th the point of reflection. the pictures below demonstrate this. pivot vector should be aligned with the distributed matrix a. for pivoting the rows of sub( a ), ipiv should be distributed along ipiv should be distributed along a process row and replicated over the result are only available in the scope of sub( x ), i.e if sub( x ) is distributed along a process row, the correct results ar is distributed along a process column, the correct results are only sub( a ). this routine assumes that the pivoting information has already been broadcast along the process row or column same mb (or nb) block. if you want to pivot a full matrix, use the scaling factor are stored along process rows in sr and alon greatly the application of the factors. |
| alpha alpha goto put in by g. henry to fix alpha proble gp = ( ( oldgp+p )-( d( l )-p ) ) / c = v' * h alpha = - tau * c / however, the traditional way of computing v requires that tau h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ), h' * h = i pclase2 initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th operand is distributed. pclaset initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ), h' * h = i pdlase2 initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th operand is distributed. pdlaset initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th c = v' * h alpha = - tau * c / however, the traditional way of computing v requires that tau h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ), h' * h = i pslase2 initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th operand is distributed. pslaset initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th c = v' * h alpha = - tau * c / however, the traditional way of computing v requires that tau c = v' * h alpha = - tau * c / however, the traditional way of computing v requires that tau h * sub( x ) = h * ( x(iax,jax) ) = ( alpha ), h' * h = i pzlase2 initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th operand is distributed. pzlaset initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th goto put in by g. henry to fix alpha proble gp = ( ( oldgp+p )-( d( l )-p ) ) / |
| already already with the active submatrix in rows and columns l to i. eigenvalues i+1 to ihi have already converged. either l = ilo, o s (local input/output) double precision array, dimension lds on entry, a matrix already in schur form the eigenvalues. the resulting matrix is no longer want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+jhi:ja+n-1. see further details. if n > 0, ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+ihi:ja+n-1. see further details. if n > 0, iteration of the loop works with the active submatrix in rows and columns l to i. eigenvalues i+1 to ihi have already so that the matrix splits. sub( a ). this routine assumes that the pivoting information has already been broadcast along the process row or column same mb (or nb) block. if you want to pivot a full matrix, use want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+jhi:ja+n-1. see further details. if n > 0, ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+ihi:ja+n-1. see further details. if n > 0, iteration of the loop works with the active submatrix in rows and columns l to i. eigenvalues i+1 to ihi have already so that the matrix splits. sub( a ). this routine assumes that the pivoting information has already been broadcast along the process row or column same mb (or nb) block. if you want to pivot a full matrix, use want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+jhi:ja+n-1. see further details. if n > 0, ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+ihi:ja+n-1. see further details. if n > 0, iteration of the loop works with the active submatrix in rows and columns l to i. eigenvalues i+1 to ihi have already so that the matrix splits. sub( a ). this routine assumes that the pivoting information has already been broadcast along the process row or column same mb (or nb) block. if you want to pivot a full matrix, use want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+jhi:ja+n-1. see further details. if n > 0, ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+ihi:ja+n-1. see further details. if n > 0, iteration of the loop works with the active submatrix in rows and columns l to i. eigenvalues i+1 to ihi have already so that the matrix splits. sub( a ). this routine assumes that the pivoting information has already been broadcast along the process row or column same mb (or nb) block. if you want to pivot a full matrix, use want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th want to find errors with min( ), so if no error, set it to a big number. if there already is an error, multiply by the th s (local input/output) real array, dimension lds on entry, a matrix already in schur form the eigenvalues. the resulting matrix is no longer with the active submatrix in rows and columns l to i. eigenvalues i+1 to ihi have already converged. either l = ilo, o |
| also also note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the error bounds on the solution and a condition estimate are also completion. if the input parameters are incorrect, work(1) may also be incorrect if jobz='n' work(1) = minimal workspace for eigenvalues only. guarantee completion. if the input parameters are incorrect, rwork(1) may also be incorrect lrwork (local input) integer pchengst also calls pchegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb routine returns the matrices v and t which determine q as a block reflector i - v*t*v', and also the matrix y = a * v * t this is an auxiliary routine called by pcgehrd. in the following specifies how the vectors which define the elementary reflectors are stored (see also further details) = 'r': rowwise specifies how the vectors which define the elementary reflectors are stored (see also further details) = 'r': rowwise already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pclapiv. note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the error bounds on the solution and a condition estimate are also a m-by-k matrix where y can be a, af, b and x. note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the upper triangular part is not referenced. if diag = 'u', the diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also no referenced. if diag = 'u', the diagonal elements of sub( a ) are also of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assume matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the error bounds on the solution and a condition estimate are also equation via the routine slaed4 (as called by pdlaed3). this routine also calculates the eigenvectors of the curren matrices v and t which determine q as a block reflector i - v*t*v', and also the matrix y = a * v * t this is an auxiliary routine called by pdgehrd. in the following specifies how the vectors which define the elementary reflectors are stored (see also further details) = 'r': rowwise specifies how the vectors which define the elementary reflectors are stored (see also further details) = 'r': rowwise already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pdlapiv. note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the error bounds on the solution and a condition estimate are also a m-by-k matrix where y can be a, af, b and x. note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the the actual number of eigenvalues found. 0 <= m <= n. (see also the description of info=2 nsplit (global output) integer = 'n': compute eigenvalues only. (not implemented yet) = 'i': compute eigenvectors of tridiagonal matrix also matrix also. on entry, z contains the orthogonal needed to guarantee completion. if the input parameters are incorrect, work(1) may also b siam j. sci. comput., 6:20 (1999), pp. 2223--2236. (see also lapack working note 132 pdsyngst also calls pdhegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb upper triangular part is not referenced. if diag = 'u', the diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also no referenced. if diag = 'u', the diagonal elements of sub( a ) are also of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assume matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the error bounds on the solution and a condition estimate are also equation via the routine slaed4 (as called by pslaed3). this routine also calculates the eigenvectors of the curren matrices v and t which determine q as a block reflector i - v*t*v', and also the matrix y = a * v * t this is an auxiliary routine called by psgehrd. in the following specifies how the vectors which define the elementary reflectors are stored (see also further details) = 'r': rowwise specifies how the vectors which define the elementary reflectors are stored (see also further details) = 'r': rowwise already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pslapiv. note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the error bounds on the solution and a condition estimate are also a m-by-k matrix where y can be a, af, b and x. note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the the actual number of eigenvalues found. 0 <= m <= n. (see also the description of info=2 nsplit (global output) integer = 'n': compute eigenvalues only. (not implemented yet) = 'i': compute eigenvectors of tridiagonal matrix also matrix also. on entry, z contains the orthogonal needed to guarantee completion. if the input parameters are incorrect, work(1) may also b siam j. sci. comput., 6:20 (1999), pp. 2223--2236. (see also lapack working note 132 pssyngst also calls pshegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb upper triangular part is not referenced. if diag = 'u', the diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also no referenced. if diag = 'u', the diagonal elements of sub( a ) are also of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assume matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the error bounds on the solution and a condition estimate are also completion. if the input parameters are incorrect, work(1) may also be incorrect if jobz='n' work(1) = minimal workspace for eigenvalues only. guarantee completion. if the input parameters are incorrect, rwork(1) may also be incorrect lrwork (local input) integer pzhengst also calls pzhegst when insufficient workspace i performance only when lwork >= 2 * np0 * nb + nq0 * nb + nb * nb routine returns the matrices v and t which determine q as a block reflector i - v*t*v', and also the matrix y = a * v * t this is an auxiliary routine called by pzgehrd. in the following specifies how the vectors which define the elementary reflectors are stored (see also further details) = 'r': rowwise specifies how the vectors which define the elementary reflectors are stored (see also further details) = 'r': rowwise already been broadcast along the process row or column. also note that this routine will only work for k1-k2 being in th pzlapiv. note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the error bounds on the solution and a condition estimate are also a m-by-k matrix where y can be a, af, b and x. note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the note: in all cases where 1d descriptors are used, 2d descriptors may also be used, since a one-dimensional array is a special cas the two-dimensional array used in this case *must* be of the upper triangular part is not referenced. if diag = 'u', the diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also no referenced. if diag = 'u', the diagonal elements of sub( a ) are also of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assume matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer |
| alter alter pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee pivot indices for local factorizations. users *should not* alter the contents betwee |
| altered altered separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pcdbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pcdttrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pcgbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pcpbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pcpttrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pddbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pddttrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pdgbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer w (global output) double precision array, dimension (n) the first k values of the final deflation-altered z-vecto w (global output) double precision array, dimension (n) the first k values of the final deflation-altered z-vecto separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pdpbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pdpttrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using psdbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using psdttrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using psgbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer w (global output) real array, dimension (n) the first k values of the final deflation-altered z-vecto w (global output) real array, dimension (n) the first k values of the final deflation-altered z-vecto separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pspbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pspttrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pzdbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pzdttrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pzgbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pzpbtrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered is to be solved using pzpttrs after the factorization routine, af *must not be altered* after the factorization laf (local input) integer |
| Although Although Although all processes call pcgemr2d, only the processes that ow first column of b receive data. the calls to cgebs2d/cgebr2d Although all processes call pdgemr2d, only the processes that ow first column of b receive data. the calls to dgebs2d/dgebr2d Although all processes call psgemr2d, only the processes that ow first column of b receive data. the calls to sgebs2d/sgebr2d Although all processes call pzgemr2d, only the processes that ow first column of b receive data. the calls to zgebs2d/zgebr2d |
| always always the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error specifies the form of equilibration that was done. = 'n': no equilibration (always true if fact = 'n') been premultiplied by diag(r). and sufficient workspace to compute them. (see lwork below.) pcheevx is always able to detect insufficient space withou compensate for the scaling performed in this routine. at present, scale is always returned as 1.0, it i and sufficient workspace to compute them. (see lwork below.) pchegvx is always able to detect insufficient space withou compensate for the scaling performed in this routine. at present, scale is always returned as 1.0, it i intermediate steps as loops over ki. their current "task" over the global m to i-1 values is always k1(ki) to k2(ki) go past that range while later bulges (ki+1,ki+2,etc..) are i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore ipiv must always be a distributed vector (not a matrix). thus jp must be 1 the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error specifies the form of equilibration that was done. = 'n': no equilibration (always true if fact = 'n') diag(sr) * a * diag(sc). 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. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error specifies the form of equilibration that was done. = 'n': no equilibration (always true if fact = 'n') been premultiplied by diag(r). intermediate steps as loops over ki. their current "task" over the global m to i-1 values is always k1(ki) to k2(ki) go past that range while later bulges (ki+1,ki+2,etc..) are i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore ipiv must always be a distributed vector (not a matrix). thus jp must be 1 the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error specifies the form of equilibration that was done. = 'n': no equilibration (always true if fact = 'n') diag(sr) * a * diag(sc). and sufficient workspace to compute them. (see lwork below.) pdsyevx is always able to detect insufficient space withou compensate for the scaling performed in this routine. at present, scale is always returned as 1.0, it i and sufficient workspace to compute them. (see lwork below.) pdsygvx is always able to detect insufficient space withou compensate for the scaling performed in this routine. at present, scale is always returned as 1.0, it i 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. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error specifies the form of equilibration that was done. = 'n': no equilibration (always true if fact = 'n') been premultiplied by diag(r). intermediate steps as loops over ki. their current "task" over the global m to i-1 values is always k1(ki) to k2(ki) go past that range while later bulges (ki+1,ki+2,etc..) are i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore ipiv must always be a distributed vector (not a matrix). thus jp must be 1 the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error specifies the form of equilibration that was done. = 'n': no equilibration (always true if fact = 'n') diag(sr) * a * diag(sc). and sufficient workspace to compute them. (see lwork below.) pssyevx is always able to detect insufficient space withou compensate for the scaling performed in this routine. at present, scale is always returned as 1.0, it i and sufficient workspace to compute them. (see lwork below.) pssygvx is always able to detect insufficient space withou compensate for the scaling performed in this routine. at present, scale is always returned as 1.0, it i 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. the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error specifies the form of equilibration that was done. = 'n': no equilibration (always true if fact = 'n') been premultiplied by diag(r). and sufficient workspace to compute them. (see lwork below.) pzheevx is always able to detect insufficient space withou compensate for the scaling performed in this routine. at present, scale is always returned as 1.0, it i and sufficient workspace to compute them. (see lwork below.) pzhegvx is always able to detect insufficient space withou compensate for the scaling performed in this routine. at present, scale is always returned as 1.0, it i intermediate steps as loops over ki. their current "task" over the global m to i-1 values is always k1(ki) to k2(ki) go past that range while later bulges (ki+1,ki+2,etc..) are i am not sure that this works correctly when ib and jb are not equal to 1. indeed, i suspect that ib should always be set to 1 or ignore ipiv must always be a distributed vector (not a matrix). thus jp must be 1 the estimate is as reliable as the estimate for rcond, and is almost always a slight overestimate of the true error specifies the form of equilibration that was done. = 'n': no equilibration (always true if fact = 'n') diag(sr) * a * diag(sc). 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. |
| AMAX AMAX ccombAMAX1 finds the element having maximum real part absolut the smallest r(i) to the largest r(i) (ia <= i <= ia+m-1). if rowcnd >= 0.1 and AMAX is neither too large nor too small AMAX (global input) rea AMAX (global input) rea value of a distributed vector sub( x ). the global index is returned in indx and the value is returned in AMAX where sub( x ) denotes x(ix:ix+n-1,jx) if incx = 1, 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 wort the smallest r(i) to the largest r(i) (ia <= i <= ia+m-1). if rowcnd >= 0.1 and AMAX is neither too large nor too small AMAX (global input) double precisio AMAX (global input) double precisio 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 wort the smallest r(i) to the largest r(i) (ia <= i <= ia+m-1). if rowcnd >= 0.1 and AMAX is neither too large nor too small AMAX (global input) rea AMAX (global input) rea 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 wort the smallest r(i) to the largest r(i) (ia <= i <= ia+m-1). if rowcnd >= 0.1 and AMAX is neither too large nor too small AMAX (global input) double precisio AMAX (global input) double precisio value of a distributed vector sub( x ). the global index is returned in indx and the value is returned in AMAX where sub( x ) denotes x(ix:ix+n-1,jx) if incx = 1, 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 wort zcombAMAX1 finds the element having maximum real part absolut |
| among among eigenvectors that are to be orthogonalized are computed by the same process. pcstein decides on the allocation of work among th individual process. if insufficient workspace is allocated, the eigenvectors that are to be orthogonalized are computed by the same process. pdstein decides on the allocation of work among th individual process. if insufficient workspace is allocated, the eigenvectors that are to be orthogonalized are computed by the same process. psstein decides on the allocation of work among th individual process. if insufficient workspace is allocated, the eigenvectors that are to be orthogonalized are computed by the same process. pzstein decides on the allocation of work among th individual process. if insufficient workspace is allocated, the |
| amongst amongst it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, |
| amount amount if eigenvectors are requested (jobz = 'v' ) then the amount of workspace required dimension max(3,lrwork) on return, work(1) contains the optimal amount o if jobz='n' rwork(1) = optimal amount of workspace scale (global output) real amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is dimension max(3,lrwork) on return, rwork(1) contains the amount of workspac if jobz='n' rwork(1) = optimal amount of workspace scale (global output) real amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is parts: 1.) the minimum amount of work it takes to determin the critical path.) (loops 50-120) dimension ( 3*n+p+1 ) on return, iwork(1) contains the amount of integer workspac on return, the iwork(2) through iwork(p+2) indicate parts: 1.) the minimum amount of work it takes to determin the critical path.) (loops 130-180) dimension ( 3*n+p+1 ) on return, iwork(1) contains the amount of integer workspac on return, the iwork(2) through iwork(p+2) indicate if jobz='n' work(1) = minimal=optimal amount of workspac generate all the eigenvectors. dimension max(3,lwork) on return, work(1) contains the optimal amount o if jobz='n' work(1) = optimal amount of workspace scale (global output) double precision amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is dimension max(3,lwork) if jobz='n' work(1) = optimal amount of workspac if jobz='v' work(1) = optimal amount of workspace scale (global output) double precision amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is parts: 1.) the minimum amount of work it takes to determin the critical path.) (loops 130-180) dimension ( 3*n+p+1 ) on return, iwork(1) contains the amount of integer workspac on return, the iwork(2) through iwork(p+2) indicate if jobz='n' work(1) = minimal=optimal amount of workspac generate all the eigenvectors. dimension max(3,lwork) on return, work(1) contains the optimal amount o if jobz='n' work(1) = optimal amount of workspace scale (global output) real amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is dimension max(3,lwork) if jobz='n' work(1) = optimal amount of workspac if jobz='v' work(1) = optimal amount of workspace scale (global output) real amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is if eigenvectors are requested (jobz = 'v' ) then the amount of workspace required dimension max(3,lrwork) on return, work(1) contains the optimal amount o if jobz='n' rwork(1) = optimal amount of workspace scale (global output) double precision amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is dimension max(3,lrwork) on return, rwork(1) contains the amount of workspac if jobz='n' rwork(1) = optimal amount of workspace scale (global output) double precision amount by which the eigenvalues should be scaled t at present, scale is always returned as 1.0, it is parts: 1.) the minimum amount of work it takes to determin the critical path.) (loops 50-120) dimension ( 3*n+p+1 ) on return, iwork(1) contains the amount of integer workspac on return, the iwork(2) through iwork(p+2) indicate |
| analagous analagous algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: algorithm is used. for a linear system, a parallel front solve followed by an analagous backsolve, both using the structur 3) backsubsitution phase: |
| Analogously Analogously the matrix u when distributed 1-dimensional "column" of processes. Analogously, ncvt is equal to the local numbe 1-dimensional "row" of processes. calling the lapack the matrix u when distributed 1-dimensional "column" of processes. Analogously, ncvt is equal to the local numbe 1-dimensional "row" of processes. calling the lapack the matrix u when distributed 1-dimensional "column" of processes. Analogously, ncvt is equal to the local numbe 1-dimensional "row" of processes. calling the lapack the matrix u when distributed 1-dimensional "column" of processes. Analogously, ncvt is equal to the local numbe 1-dimensional "row" of processes. calling the lapack |
| ANB ANB where lwork is as defined above, and nhetrd_lwork = n + 2*( ANB+1 )*( 4*nps+2 ) where lwork is as defined above, and nhetrd_lwork = 2*( ANB+1 )*( 4*nps+2 ) nhegst_lwopt = 2*np0*nb + nq0*nb + nb*nb for optimal performance, greater workspace is needed, i.e. lwork >= 2*( ANB+1 )*( 4*nps+2 ) + ( nps + 4 ) * np anb = pjlaenv( ictxt, 3, 'pchettrd', 'l', 0, 0, 0, 0 ) the dimension of the array work. lwork >= 2*( ANB+1 )*( 4*nps+2 ) + np nps = max( numroc( n, 1, 0, 0, nprow ), 2*anb ) of eigenvectors requested, and nsytrd_lwopt = n + 2*( ANB+1 )*( 4*nps+2 ) of eigenvectors requested, and nsytrd_lwopt = n + 2*( ANB+1 )*( 4*nps+2 ) nsygst_lwopt = 2*np0*nb + nq0*nb + nb*nb for optimal performance, greater workspace is needed, i.e. lwork >= 2*( ANB+1 )*( 4*nps+2 ) + ( nps + 4 ) * np anb = pjlaenv( ictxt, 3, 'pdsyttrd', 'l', 0, 0, 0, 0 ) the dimension of the array work. lwork >= 2*( ANB+1 )*( 4*nps+2 ) + np nps = max( numroc( n, 1, 0, 0, nprow ), 2*anb ) of eigenvectors requested, and nsytrd_lwopt = n + 2*( ANB+1 )*( 4*nps+2 ) of eigenvectors requested, and nsytrd_lwopt = n + 2*( ANB+1 )*( 4*nps+2 ) nsygst_lwopt = 2*np0*nb + nq0*nb + nb*nb for optimal performance, greater workspace is needed, i.e. lwork >= 2*( ANB+1 )*( 4*nps+2 ) + ( nps + 4 ) * np anb = pjlaenv( ictxt, 3, 'pssyttrd', 'l', 0, 0, 0, 0 ) the dimension of the array work. lwork >= 2*( ANB+1 )*( 4*nps+2 ) + np nps = max( numroc( n, 1, 0, 0, nprow ), 2*anb ) where lwork is as defined above, and nhetrd_lwork = n + 2*( ANB+1 )*( 4*nps+2 ) where lwork is as defined above, and nhetrd_lwork = 2*( ANB+1 )*( 4*nps+2 ) nhegst_lwopt = 2*np0*nb + nq0*nb + nb*nb for optimal performance, greater workspace is needed, i.e. lwork >= 2*( ANB+1 )*( 4*nps+2 ) + ( nps + 4 ) * np anb = pjlaenv( ictxt, 3, 'pzhettrd', 'l', 0, 0, 0, 0 ) the dimension of the array work. lwork >= 2*( ANB+1 )*( 4*nps+2 ) + np nps = max( numroc( n, 1, 0, 0, nprow ), 2*anb ) |
| and and v1 (local input/local output) complex array of dimension 2. the first maximum absolute value element and cdbtrf computes an lu factorization of a real m-by-n band matrix the block size must not exceed the limit set by the size of the local arrays work13 and work31 where l is a product of unit lower bidiagonal matrices and u is upper triangular with nonzeros in only the mai i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. clamsh should only be called when there are multiple shifts/bulges (nbulge > 1) and the first shift is starting in the middle of a small subdiagonal elements. block (global input) logical if .true., then apply several reflectors at once and rea if .false., apply the single reflector given by v2, v3, specifies whether the superdiagonal or the subdiagonal of the tridiagonal matrix a is stored and the form of th = 'u': e is the superdiagonal of u, and a = u'*d*u; x := conjg( t' ) *y, and w := t *z where x is an n element vector and t is an n by n ddbtrf computes an lu factorization of a real m-by-n band matrix the block size must not exceed the limit set by the size of the local arrays work13 and work31 where l is a product of unit lower bidiagonal matrices and u is upper triangular with nonzeros in only the mai dlamsh should only be called when there are multiple shifts/bulges (nbulge > 1) and the first shift is starting in the middle of a subdiagonal elements. partition d( start:endd ) and stack parts, largest one firs choose partition entry as median of 3 block (global input) logical if .true., then apply several reflectors at once and rea if .false., apply the single reflector given by v2, v3, dlasorte sorts eigenpairs so that real eigenpairs are together and since every 2nd subdiagonal is guaranteed to be zero. partition d( start:endd ) and stack parts, largest one firs choose partition entry as median of 3 initialize seed for random number generator dlarnv determine the unit roundoff and over/underflow thresholds x := t' *y, and w := t *z where x is an n element vector and t is an n by n where a(1:n, ja:ja+n-1) is an n-by-n complex banded diagonally dominant-like distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pcdbtrf banded diagonally dominant-like distributed convert descriptor into standard form for easy access t see pcdttrf and pcdttrs for details ===================================================================== convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pcdttrf tridiagonal diagonally dominant-like distributed convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is an n-by-n complex banded distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pcgbtrf banded distributed vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), and rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1) ) * pcgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pcgerfs improves the computed solution to a system of linear equations and provides error bounds and backward error estimates fo vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed matrix and x and sub( b ) = b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrh pcgesvd computes the singular value decomposition (svd) of an m-by-n matrix a, optionally computing the left and/or righ where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an permutation matrix, l is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and u is upper triangula permutation matrix, l is lower triangular with unit diagonal ele- ments (lower trapezoidal if m > n), and u is upper triangula pcgetri computes the inverse of a distributed matrix using the lu factorization computed by pcgetrf. this method inverts u and the inva by solving the system inva*l = inv(u) for inva. sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a, a**t or a**h and sub( b ) denotes b(ib:ib+n-1,jb:jb+nrhs-1) notes pcggqrf computes a generalized qr factorization of an n-by-m matrix sub( a ) = a(ia:ia+n-1,ja:ja+m-1) and an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) and a p-by-n matrix sub( b ) = b(ib:ib+p-1,jb:jb+n-1) sub( a ) = r*q, sub( b ) = z*t*q, pcheev computes selected eigenvalues and, optionally, eigenvector of scalapack routines. pcheevd computes all the eigenvalues and eigenvectors of a hermitia pcheevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by pchegs2 reduces a complex hermitian-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pchegst reduces a complex hermitian-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pchegvx computes all the eigenvalues, and optionally of a complex generalized hermitian-definite eigenproblem, of the form pchengst reduces a complex hermitian-definite generalized eigenproblem to standard form pchengst performs the same function as pchegst, but is based on the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowe documented below. (search for "restrictions".) vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its correspondin pclabrd reduces the first nb rows and columns of a complex genera or lower bidiagonal form by an unitary transformation q' * a * p, and pclacgv conjugates a complex vector of length n, sub( x ), where sub( x ) denotes x(ix,jx:jx+n-1) if incx = descx( m_ ) and a. reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, thi seeing the effect of starting a double shift qr iteration given by h44, h33, & h43h34 and see if this would make performs a local copy sub( a ) := sub( b ), where sub( a ) denotes a(ia:ia+m-1,ja:ja+n-1) and sub( b ) denotes b(ib:ib+m-1,jb:jb+n-1) distributed. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces performs a local copy sub( a ) := sub( b ), where sub( a ) denotes a(ia:ia+m-1,ja:ja+n-1) and sub( b ) denotes b(ib:ib+m-1,jb:jb+n-1) notes pclaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. performed by an unitary similarity transformation q' * a * q. the routine returns the matrices v and t which determine q as a bloc i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. ( max(abs(a(i,j))), norm = 'm' or 'm' with ia <= i <= ia+m-1, ( and ja <= j <= ja+n-1 ( norm1( sub( a ) ), norm = '1', 'o' or 'o' get grid parameters and local indexes handle first block of columns separatel get grid parameters and local indexes find sum of global matrix columns and store on row 0 o for example if the row pivots should be applied to the columns of sub( a ), pass rowcol='c' and pivroc='c' notes pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. similarly all process columns for column pivoting. pclaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scalin sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in the vectors sr and sc notes send v and tau to the process column icco vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces send v and tau to the process column icco 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 if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. send v and tau to the process column iccol currently, only storev = 'r' and direct = 'b' are supported notes send v and tau to the process column iccol if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pclase2 initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th operand is distributed. pclaset initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pclassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pclatrd reduces nb rows and columns of a complex hermitia tridiagonal form by an unitary similarity transformation where z is an n-by-n unitary matrix and r is an m-by-m uppe compute grow = 1/g(j) and xbnd = 1/m(j) vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces value of a distributed vector sub( x ). the global index is returned in indx and the value is returned in amax 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 complex banded symmetric positive definite distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pcpbtrf banded symmetric positive definite distributed convert descriptor into standard form for easy access t an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), and rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1) ) * pcpoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number equations when the coefficient matrix is hermitian positive definite and provides error bounds and backward error estimates for th 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 vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 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. see pcpttrf and pcpttrs for details ===================================================================== convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pcpttrf tridiagonal symmetric positive definite distributed convert descriptor into standard form for easy access t vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces process. pcstein decides on the allocation of work among the processes and then calls sstein2 (modified lapack routine) on eac expected orthogonalization may not be done. the norm of a(ia:ia+n-1,ja:ja+n-1) is computed and an estimate i of the condition number is computed as pctrevc computes some or all of the right and/or left eigenvectors o pctrrfs provides error bounds and backward error estimates for th coefficient matrix. block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be contained in one and only one process memory space (local operation) notes vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 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 vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces as returned by pcgeqlf. q is of order m if side = 'l' and of order as returned by pcgeqrf. q is of order m if side = 'l' and of order here q and p**h are the unitary distributed matrices determined b bidiagonal form: a(ia:*,ja:*) = q * b * p**h. q and p**h are defined where q is a complex unitary distributed matrix of order nq, with nq = m if side = 'l' and nq = n if side = 'r'. q is defined as th as returned by pcgelqf. q is of order m if side = 'l' and of order as returned by pcgelqf. q is of order m if side = 'l' and of order as returned by pcgeqlf. q is of order m if side = 'l' and of order as returned by pcgeqrf. q is of order m if side = 'l' and of order as returned by pcgerqf. q is of order m if side = 'l' and of order as returned by pctzrzf. q is of order m if side = 'l' and of order as returned by pcgerqf. q is of order m if side = 'l' and of order as returned by pctzrzf. q is of order m if side = 'l' and of order where q is a complex unitary distributed matrix of order nq, with nq = m if side = 'l' and nq = n if side = 'r'. q is defined as th where a(1:n, ja:ja+n-1) is an n-by-n real banded diagonally dominant-like distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pddbtrf banded diagonally dominant-like distributed convert descriptor into standard form for easy access t see pddttrf and pddttrs for details ===================================================================== convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pddttrf tridiagonal diagonally dominant-like distributed convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is an n-by-n real banded distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pdgbtrf banded distributed vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), and rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1) ) * pdgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pdgerfs improves the computed solution to a system of linear equations and provides error bounds and backward error estimates fo vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed matrix and x and sub( b ) = b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrh pdgesvd computes the singular value decomposition (svd) of an m-by-n matrix a, optionally computing the left and/or righ where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an permutation matrix, l is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and u is upper triangula permutation matrix, l is lower triangular with unit diagonal ele- ments (lower trapezoidal if m > n), and u is upper triangula pdgetri computes the inverse of a distributed matrix using the lu factorization computed by pdgetrf. this method inverts u and the inva by solving the system inva*l = inv(u) for inva. factorization computed by pdgetrf. sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a or a**t and pdggqrf computes a generalized qr factorization of an n-by-m matrix sub( a ) = a(ia:ia+n-1,ja:ja+m-1) and an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) and a p-by-n matrix sub( b ) = b(ib:ib+p-1,jb:jb+n-1) sub( a ) = r*q, sub( b ) = z*t*q, pdlabad takes as input the values computed by pdlamch for underflow and overflow, and returns the square root of each of these values i to identify machines with a large exponent range, such as the crays, pdlabrd reduces the first nb rows and columns of a real genera or lower bidiagonal form by an orthogonal transformation q' * a * p, reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, this informatio seeing the effect of starting a double shift qr iteration given by h44, h33, & h43h34 and see if this would make performs a local copy sub( a ) := sub( b ), where sub( a ) denotes a(ia:ia+m-1,ja:ja+n-1) and sub( b ) denotes b(ib:ib+m-1,jb:jb+n-1) distributed. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces performs a local copy sub( a ) := sub( b ), where sub( a ) denotes a(ia:ia+m-1,ja:ja+n-1) and sub( b ) denotes b(ib:ib+m-1,jb:jb+n-1) notes contained in the input intervals [ intvl(2*j-1), intvl(2*j) ] where j = 1,...,minp. it uses and computes the function n(w), which i or equal to its argument w. this is a scalapack internal procedure and arguments are not checke pdlaed0 computes all eigenvalues and corresponding eigenvectors of where z = q'u, u is a vector of length n with ones in the n1 and n1 + 1 th elements and zeros elsewhere the eigenvectors of the original matrix are stored in q, and the ictxt (global input) integer the blacs context handle, indicating the global context o pdlaed3 finds the roots of the secular equation, as defined by the values in d, w, and rho, between 1 and k. it makes th pdlaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. 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' i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. ( max(abs(a(i,j))), norm = 'm' or 'm' with ia <= i <= ia+m-1, ( and ja <= j <= ja+n-1 ( norm1( sub( a ) ), norm = '1', 'o' or 'o' handle first block of columns separatel get grid parameters and local indexes find sum of global matrix columns and store on row 0 o this implementation of the sturm sequence loop has conditionals in the innermost loop to avoid overflow and determine the sign of implementation of the sturm sequence loop. for example if the row pivots should be applied to the columns of sub( a ), pass rowcol='c' and pivroc='c' notes pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. similarly all process columns for column pivoting. pdlaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scalin sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in the vectors sr and sc notes it assumes that the input array, bycol, is distributed across rows and that all process columns contain the same copy o and will contain the entire array. it assumes that the input array, byrow, is distributed across columns and that all process rows contain the same copy o and will contain the entire array. send v and tau to the process column icco vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces where alpha is a scalar, and sub( x ) is an (n-1)-element rea incx = descx(m_). h is represented in the form if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. send v and tau to the process column iccol currently, only storev = 'r' and direct = 'b' are supported notes if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pdlase2 initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th operand is distributed. pdlaset initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pdlasrt sort the numbers in d in increasing order and th pdlassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pdlatrd reduces nb rows and columns of a real symmetric distribute form by an orthogonal similarity transformation q' * sub( a ) * q, where z is an n-by-n orthogonal matrix and r is an m-by-m uppe vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces as returned by pdgeqlf. q is of order m if side = 'l' and of order as returned by pdgeqrf. q is of order m if side = 'l' and of order here q and p**t are the orthogonal distributed matrices determined b bidiagonal form: a(ia:*,ja:*) = q * b * p**t. q and p**t are defined where q is a real orthogonal distributed matrix of order nq, with nq = m if side = 'l' and nq = n if side = 'r'. q is defined as th as returned by pdgelqf. q is of order m if side = 'l' and of order as returned by pdgelqf. q is of order m if side = 'l' and of order as returned by pdgeqlf. q is of order m if side = 'l' and of order as returned by pdgeqrf. q is of order m if side = 'l' and of order as returned by pdgerqf. q is of order m if side = 'l' and of order as returned by pdtzrzf. q is of order m if side = 'l' and of order as returned by pdgerqf. q is of order m if side = 'l' and of order as returned by pdtzrzf. q is of order m if side = 'l' and of order where q is a real orthogonal distributed matrix of order nq, with nq = m if side = 'l' and nq = n if side = 'r'. q is defined as th where a(1:n, ja:ja+n-1) is an n-by-n real banded symmetric positive definite distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pdpbtrf banded symmetric positive definite distributed convert descriptor into standard form for easy access t an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), and rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1) ) * pdpoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number equations when the coefficient matrix is symmetric positive definite and provides error bounds and backward error estimates for th 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 vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 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. see pdpttrf and pdpttrs for details ===================================================================== convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pdpttrf tridiagonal symmetric positive definite distributed convert descriptor into standard form for easy access t vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces ictxt (global input) integer the blacs context handle range (global input) character ======= pdstedc computes all eigenvalues and eigenvectors of conquer algorithm. process. pdstein decides on the allocation of work among the processes and then calls dstein2 (modified lapack routine) on eac expected orthogonalization may not be done. pdsyev computes all eigenvalues and, optionally, eigenvector of scalapack routines. pdsyevd computes all the eigenvalues and eigenvector of scalapack routines. pdsyevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by pdsygs2 reduces a real symmetric-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pdsygst reduces a real symmetric-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pdsygvx computes all the eigenvalues, and optionally of a real generalized sy-definite eigenproblem, of the form pdsyngst reduces a complex hermitian-definite generalized eigenproblem to standard form pdsyngst performs the same function as pdhegst, but is based on the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowe documented below. (search for "restrictions".) vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its correspondin the norm of a(ia:ia+n-1,ja:ja+n-1) is computed and an estimate i of the condition number is computed as pdtrrfs provides error bounds and backward error estimates for th coefficient matrix. block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be contained in one and only one process memory space (local operation) notes vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 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 vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pjlaenv is called from the scalapack symmetric and hermitia problem-dependent parameters for the local environment. see ispec vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces where a(1:n, ja:ja+n-1) is an n-by-n real banded diagonally dominant-like distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by psdbtrf banded diagonally dominant-like distributed convert descriptor into standard form for easy access t see psdttrf and psdttrs for details ===================================================================== convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by psdttrf tridiagonal diagonally dominant-like distributed convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is an n-by-n real banded distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by psgbtrf banded distributed vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), and rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1) ) * psgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces psgerfs improves the computed solution to a system of linear equations and provides error bounds and backward error estimates fo vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed matrix and x and sub( b ) = b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrh psgesvd computes the singular value decomposition (svd) of an m-by-n matrix a, optionally computing the left and/or righ where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an permutation matrix, l is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and u is upper triangula permutation matrix, l is lower triangular with unit diagonal ele- ments (lower trapezoidal if m > n), and u is upper triangula psgetri computes the inverse of a distributed matrix using the lu factorization computed by psgetrf. this method inverts u and the inva by solving the system inva*l = inv(u) for inva. factorization computed by psgetrf. sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a or a**t and psggqrf computes a generalized qr factorization of an n-by-m matrix sub( a ) = a(ia:ia+n-1,ja:ja+m-1) and an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) and a p-by-n matrix sub( b ) = b(ib:ib+p-1,jb:jb+n-1) sub( a ) = r*q, sub( b ) = z*t*q, pslabad takes as input the values computed by pslamch for underflow and overflow, and returns the square root of each of these values i to identify machines with a large exponent range, such as the crays, pslabrd reduces the first nb rows and columns of a real genera or lower bidiagonal form by an orthogonal transformation q' * a * p, reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, this informatio seeing the effect of starting a double shift qr iteration given by h44, h33, & h43h34 and see if this would make performs a local copy sub( a ) := sub( b ), where sub( a ) denotes a(ia:ia+m-1,ja:ja+n-1) and sub( b ) denotes b(ib:ib+m-1,jb:jb+n-1) distributed. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces performs a local copy sub( a ) := sub( b ), where sub( a ) denotes a(ia:ia+m-1,ja:ja+n-1) and sub( b ) denotes b(ib:ib+m-1,jb:jb+n-1) notes contained in the input intervals [ intvl(2*j-1), intvl(2*j) ] where j = 1,...,minp. it uses and computes the function n(w), which i or equal to its argument w. this is a scalapack internal procedure and arguments are not checke pslaed0 computes all eigenvalues and corresponding eigenvectors of where z = q'u, u is a vector of length n with ones in the n1 and n1 + 1 th elements and zeros elsewhere the eigenvectors of the original matrix are stored in q, and the ictxt (global input) integer the blacs context handle, indicating the global context o pslaed3 finds the roots of the secular equation, as defined by the values in d, w, and rho, between 1 and k. it makes th pslaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. 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' i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. ( max(abs(a(i,j))), norm = 'm' or 'm' with ia <= i <= ia+m-1, ( and ja <= j <= ja+n-1 ( norm1( sub( a ) ), norm = '1', 'o' or 'o' handle first block of columns separatel get grid parameters and local indexes find sum of global matrix columns and store on row 0 o this implementation of the sturm sequence loop has conditionals in the innermost loop to avoid overflow and determine the sign of implementation of the sturm sequence loop. for example if the row pivots should be applied to the columns of sub( a ), pass rowcol='c' and pivroc='c' notes pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. similarly all process columns for column pivoting. pslaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scalin sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in the vectors sr and sc notes it assumes that the input array, bycol, is distributed across rows and that all process columns contain the same copy o and will contain the entire array. it assumes that the input array, byrow, is distributed across columns and that all process rows contain the same copy o and will contain the entire array. send v and tau to the process column icco vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces where alpha is a scalar, and sub( x ) is an (n-1)-element rea incx = descx(m_). h is represented in the form if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. send v and tau to the process column iccol currently, only storev = 'r' and direct = 'b' are supported notes if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pslase2 initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th operand is distributed. pslaset initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pslasrt sort the numbers in d in increasing order and th pslassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pslatrd reduces nb rows and columns of a real symmetric distribute form by an orthogonal similarity transformation q' * sub( a ) * q, where z is an n-by-n orthogonal matrix and r is an m-by-m uppe vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces as returned by psgeqlf. q is of order m if side = 'l' and of order as returned by psgeqrf. q is of order m if side = 'l' and of order here q and p**t are the orthogonal distributed matrices determined b bidiagonal form: a(ia:*,ja:*) = q * b * p**t. q and p**t are defined where q is a real orthogonal distributed matrix of order nq, with nq = m if side = 'l' and nq = n if side = 'r'. q is defined as th as returned by psgelqf. q is of order m if side = 'l' and of order as returned by psgelqf. q is of order m if side = 'l' and of order as returned by psgeqlf. q is of order m if side = 'l' and of order as returned by psgeqrf. q is of order m if side = 'l' and of order as returned by psgerqf. q is of order m if side = 'l' and of order as returned by pstzrzf. q is of order m if side = 'l' and of order as returned by psgerqf. q is of order m if side = 'l' and of order as returned by pstzrzf. q is of order m if side = 'l' and of order where q is a real orthogonal distributed matrix of order nq, with nq = m if side = 'l' and nq = n if side = 'r'. q is defined as th where a(1:n, ja:ja+n-1) is an n-by-n real banded symmetric positive definite distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pspbtrf banded symmetric positive definite distributed convert descriptor into standard form for easy access t an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), and rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1) ) * pspoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number equations when the coefficient matrix is symmetric positive definite and provides error bounds and backward error estimates for th 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 vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 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. see pspttrf and pspttrs for details ===================================================================== convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pspttrf tridiagonal symmetric positive definite distributed convert descriptor into standard form for easy access t vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces ictxt (global input) integer the blacs context handle range (global input) character ======= psstedc computes all eigenvalues and eigenvectors of conquer algorithm. process. psstein decides on the allocation of work among the processes and then calls sstein2 (modified lapack routine) on eac expected orthogonalization may not be done. pssyev computes all eigenvalues and, optionally, eigenvector of scalapack routines. pssyevd computes all the eigenvalues and eigenvector of scalapack routines. pssyevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by pssygs2 reduces a real symmetric-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pssygst reduces a real symmetric-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pssygvx computes all the eigenvalues, and optionally of a real generalized sy-definite eigenproblem, of the form pssyngst reduces a complex hermitian-definite generalized eigenproblem to standard form pssyngst performs the same function as pshegst, but is based on the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowe documented below. (search for "restrictions".) vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its correspondin the norm of a(ia:ia+n-1,ja:ja+n-1) is computed and an estimate i of the condition number is computed as pstrrfs provides error bounds and backward error estimates for th coefficient matrix. block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be contained in one and only one process memory space (local operation) notes vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 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 complex banded diagonally dominant-like distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pzdbtrf banded diagonally dominant-like distributed convert descriptor into standard form for easy access t vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces see pzdttrf and pzdttrs for details ===================================================================== convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pzdttrf tridiagonal diagonally dominant-like distributed convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is an n-by-n complex banded distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pzgbtrf banded distributed vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), and rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1) ) * pzgeequ computes row and column scalings intended to equilibrate a reduce its condition number. r returns the row scale factors and c vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 1. if trans = 'n' and m >= n: find the least squares solution o minimize || sub( b ) - sub( a )*x ||. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pzgerfs improves the computed solution to a system of linear equations and provides error bounds and backward error estimates fo vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed matrix and x and sub( b ) = b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrh pzgesvd computes the singular value decomposition (svd) of an m-by-n matrix a, optionally computing the left and/or righ where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x an permutation matrix, l is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and u is upper triangula permutation matrix, l is lower triangular with unit diagonal ele- ments (lower trapezoidal if m > n), and u is upper triangula pzgetri computes the inverse of a distributed matrix using the lu factorization computed by pzgetrf. this method inverts u and the inva by solving the system inva*l = inv(u) for inva. sub( a ) denotes a(ia:ia+n-1,ja:ja+n-1), op( a ) = a, a**t or a**h and sub( b ) denotes b(ib:ib+n-1,jb:jb+nrhs-1) notes pzggqrf computes a generalized qr factorization of an n-by-m matrix sub( a ) = a(ia:ia+n-1,ja:ja+m-1) and an m-by-n matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) and a p-by-n matrix sub( b ) = b(ib:ib+p-1,jb:jb+n-1) sub( a ) = r*q, sub( b ) = z*t*q, pzheev computes selected eigenvalues and, optionally, eigenvector of scalapack routines. pzheevd computes all the eigenvalues and eigenvectors of a hermitia pzheevx computes selected eigenvalues and, optionally, eigenvector of scalapack routines. eigenvalues/vectors can be selected by pzhegs2 reduces a complex hermitian-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pzhegst reduces a complex hermitian-definite generalized eigenproblem to standard form in the following sub( a ) denotes a( ia:ia+n-1, ja:ja+n-1 ) and pzhegvx computes all the eigenvalues, and optionally of a complex generalized hermitian-definite eigenproblem, of the form pzhengst reduces a complex hermitian-definite generalized eigenproblem to standard form pzhengst performs the same function as pzhegst, but is based on the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowe documented below. (search for "restrictions".) vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its correspondin pzlabrd reduces the first nb rows and columns of a complex genera or lower bidiagonal form by an unitary transformation q' * a * p, and pzlacgv conjugates a complex vector of length n, sub( x ), where sub( x ) denotes x(ix,jx:jx+n-1) if incx = descx( m_ ) and a. reverse communication is used for evaluating matrix-vector products. x and v are aligned with the distributed matrix a, thi seeing the effect of starting a double shift qr iteration given by h44, h33, & h43h34 and see if this would make performs a local copy sub( a ) := sub( b ), where sub( a ) denotes a(ia:ia+m-1,ja:ja+n-1) and sub( b ) denotes b(ib:ib+m-1,jb:jb+n-1) distributed. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces performs a local copy sub( a ) := sub( b ), where sub( a ) denotes a(ia:ia+m-1,ja:ja+n-1) and sub( b ) denotes b(ib:ib+m-1,jb:jb+n-1) notes pzlaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. performed by an unitary similarity transformation q' * a * q. the routine returns the matrices v and t which determine q as a bloc i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. ( max(abs(a(i,j))), norm = 'm' or 'm' with ia <= i <= ia+m-1, ( and ja <= j <= ja+n-1 ( norm1( sub( a ) ), norm = '1', 'o' or 'o' get grid parameters and local indexes handle first block of columns separatel get grid parameters and local indexes find sum of global matrix columns and store on row 0 o for example if the row pivots should be applied to the columns of sub( a ), pass rowcol='c' and pivroc='c' notes pivoting the rows of sub( a ), ipiv should be distributed along a process column and replicated over all process rows. similarly all process columns for column pivoting. pzlaqge equilibrates a general m-by-n distributed matrix sub( a ) = a(ia:ia+m-1,ja:ja+n-1) using the row and scalin sub( a ) = a(ia:ia+n-1,ja:ja+n-1) using the scaling factors in the vectors sr and sc notes send v and tau to the process column icco vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces send v and tau to the process column icco 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 if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. send v and tau to the process column iccol currently, only storev = 'r' and direct = 'b' are supported notes send v and tau to the process column iccol if direct = 'f', h = h(1) h(2) . . . h(k) and t is upper triangular if direct = 'b', h = h(k) . . . h(2) h(1) and t is lower triangular. vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pzlase2 initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th operand is distributed. pzlaset initializes an m-by-n distributed matrix sub( a ) denoting a(ia:ia+m-1,ja:ja+n-1) to beta on the diagonal and alpha on th vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pzlassq returns the values scl and smsq such tha ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq, vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces pzlatrd reduces nb rows and columns of a complex hermitia tridiagonal form by an unitary similarity transformation where z is an n-by-n unitary matrix and r is an m-by-m uppe compute grow = 1/g(j) and xbnd = 1/m(j) vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces value of a distributed vector sub( x ). the global index is returned in indx and the value is returned in amax 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 complex banded symmetric positive definite distribute convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pzpbtrf banded symmetric positive definite distributed convert descriptor into standard form for easy access t an estimate is obtained for norm(inv(a(ia:ia+n-1,ja:ja+n-1))), and rcond = 1 / ( norm( a(ia:ia+n-1,ja:ja+n-1) ) * pzpoequ computes row and column scalings intended t sub( a ) = a(ia:ia+n-1,ja:ja+n-1) and reduce its condition number equations when the coefficient matrix is hermitian positive definite and provides error bounds and backward error estimates for th 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 vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 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. see pzpttrf and pzpttrs for details ===================================================================== convert descriptor into standard form for easy access t where a(1:n, ja:ja+n-1) is the matrix used to produce the factors stored in a(1:n,ja:ja+n-1) and af by pzpttrf tridiagonal symmetric positive definite distributed convert descriptor into standard form for easy access t process. pzstein decides on the allocation of work among the processes and then calls dstein2 (modified lapack routine) on eac expected orthogonalization may not be done. the norm of a(ia:ia+n-1,ja:ja+n-1) is computed and an estimate i of the condition number is computed as pztrevc computes some or all of the right and/or left eigenvectors o pztrrfs provides error bounds and backward error estimates for th coefficient matrix. block matrix sub( a ) = a(ia:ia+n-1,ja:ja+n-1). this matrix should be contained in one and only one process memory space (local operation) notes vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces 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 vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces vector. this vector stores the information required to establish the mapping between an object element and its corresponding proces as returned by pzgeqlf. q is of order m if side = 'l' and of order as returned by pzgeqrf. q is of order m if side = 'l' and of order here q and p**h are the unitary distributed matrices determined b bidiagonal form: a(ia:*,ja:*) = q * b * p**h. q and p**h are defined where q is a complex unitary distributed matrix of order nq, with nq = m if side = 'l' and nq = n if side = 'r'. q is defined as th as returned by pzgelqf. q is of order m if side = 'l' and of order as returned by pzgelqf. q is of order m if side = 'l' and of order as returned by pzgeqlf. q is of order m if side = 'l' and of order as returned by pzgeqrf. q is of order m if side = 'l' and of order as returned by pzgerqf. q is of order m if side = 'l' and of order as returned by pztzrzf. q is of order m if side = 'l' and of order as returned by pzgerqf. q is of order m if side = 'l' and of order as returned by pztzrzf. q is of order m if side = 'l' and of order where q is a complex unitary distributed matrix of order nq, with nq = m if side = 'l' and nq = n if side = 'r'. q is defined as th sdbtrf computes an lu factorization of a real m-by-n band matrix the block size must not exceed the limit set by the size of the local arrays work13 and work31 where l is a product of unit lower bidiagonal matrices and u is upper triangular with nonzeros in only the mai slamsh should only be called when there are multiple shifts/bulges (nbulge > 1) and the first shift is starting in the middle of a subdiagonal elements. partition d( start:endd ) and stack parts, largest one firs choose partition entry as median of 3 block (global input) logical if .true., then apply several reflectors at once and rea if .false., apply the single reflector given by v2, v3, slasorte sorts eigenpairs so that real eigenpairs are together and since every 2nd subdiagonal is guaranteed to be zero. partition d( start:endd ) and stack parts, largest one firs choose partition entry as median of 3 initialize seed for random number generator slarnv determine the unit roundoff and over/underflow thresholds x := t' *y, and w := t *z where x is an n element vector and t is an n by n v1 (local input/local output) complex*16 array of dimension 2. the first maximum absolute value element and zdbtrf computes an lu factorization of a real m-by-n band matrix the block size must not exceed the limit set by the size of the local arrays work13 and work31 where l is a product of unit lower bidiagonal matrices and u is upper triangular with nonzeros in only the mai i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. zlamsh should only be called when there are multiple shifts/bulges (nbulge > 1) and the first shift is starting in the middle of a small subdiagonal elements. block (global input) logical if .true., then apply several reflectors at once and rea if .false., apply the single reflector given by v2, v3, specifies whether the superdiagonal or the subdiagonal of the tridiagonal matrix a is stored and the form of th = 'u': e is the superdiagonal of u, and a = u'*d*u; x := conjg( t' ) *y, and w := t *z where x is an n element vector and t is an n by n |
| Andrew Andrew code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. implemented for scalapack by: Andrew j. cleary, livermore national lab and university of tenn. based on code written by : peter arbenz, eth zurich, 1996. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. implemented for scalapack by: Andrew j. cleary, livermore national lab and university of tenn. based on code written by : peter arbenz, eth zurich, 1996. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. implemented for scalapack by: Andrew j. cleary, livermore national lab and university of tenn. based on code written by : peter arbenz, eth zurich, 1996. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. implemented for scalapack by: Andrew j. cleary, livermore national lab and university of tenn. based on code written by : peter arbenz, eth zurich, 1996. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. code developer: Andrew j. cleary, university of tennessee this version released: august, 2001. |
| Andy Andy these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -Andy cleary, april 14, 1996 block sizes must be the same |
| annihilate annihilate tau is a scalar and z( k ) is an ( n - m ) element vector. tau and z( k ) are chosen to annihilate the elements of the kth ro tau is a scalar and z( k ) is an ( n - m ) element vector. tau and z( k ) are chosen to annihilate the elements of the kth ro tau is a scalar and z( k ) is an ( n - m ) element vector. tau and z( k ) are chosen to annihilate the elements of the kth ro tau is a scalar and z( k ) is an ( n - m ) element vector. tau and z( k ) are chosen to annihilate the elements of the kth ro tau is a scalar and z( k ) is an ( n - m ) element vector. tau and z( k ) are chosen to annihilate the elements of the kth ro tau is a scalar and z( k ) is an ( n - m ) element vector. tau and z( k ) are chosen to annihilate the elements of the kth ro tau is a scalar and z( k ) is an ( n - m ) element vector. tau and z( k ) are chosen to annihilate the elements of the kth ro tau is a scalar and z( k ) is an ( n - m ) element vector. tau and z( k ) are chosen to annihilate the elements of the kth ro |
| ANORM ANORM ANORM (global input) rea matrix a(ia:ia+n-1,ja:ja+n-1). ANORM (global input) rea matrix a(ia:ia+n-1,ja:ja+n-1). ANORM (global input) double precisio matrix a(ia:ia+n-1,ja:ja+n-1). ANORM (global input) double precisio matrix a(ia:ia+n-1,ja:ja+n-1). ANORM (global input) rea matrix a(ia:ia+n-1,ja:ja+n-1). ANORM (global input) rea matrix a(ia:ia+n-1,ja:ja+n-1). ANORM (global input) double precisio matrix a(ia:ia+n-1,ja:ja+n-1). ANORM (global input) double precisio matrix a(ia:ia+n-1,ja:ja+n-1). |
| another another vecs (global input) complex array of size 3*n (matrix size) this holds the size 3 reflectors one after another and thi size) this holds the size 3 reflectors one after another and thi to form q explicitly, use scalapack subroutine pcungqr. to use q to update another matrix, use scalapack subroutine pcunmqr the matrix z is represented as a product of elementary reflectors to form q explicitly, use scalapack subroutine pcungrq. to use q to update another matrix, use scalapack subroutine pcunmrq the matrix z is represented as a product of elementary reflectors pclacp2 copies all or part of a distributed matrix a to another performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pclacpy copies all or part of a distributed matrix a to another performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pclamr1d redistributes a one-dimensional row vector from one data decomposition to another this is an auxiliary routine called by pchetrd to redistribute d, e to form q explicitly, use scalapack subroutine pdorgqr. to use q to update another matrix, use scalapack subroutine pdormqr the matrix z is represented as a product of elementary reflectors to form q explicitly, use scalapack subroutine pdorgrq. to use q to update another matrix, use scalapack subroutine pdormrq the matrix z is represented as a product of elementary reflectors pdlacp2 copies all or part of a distributed matrix a to another performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pdlacpy copies all or part of a distributed matrix a to another performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pdlamr1d redistributes a one-dimensional row vector from one data decomposition to another this is an auxiliary routine called by pdsytrd to redistribute d, e work (local workspace) double precision dimension (lwork) used to hold the buffers sent from one process to another lwork (local input) integer size of work array work (local workspace) double precision dimension (lwork) used to hold the buffers sent from one process to another lwork (local input) integer size of work array to form q explicitly, use scalapack subroutine psorgqr. to use q to update another matrix, use scalapack subroutine psormqr the matrix z is represented as a product of elementary reflectors to form q explicitly, use scalapack subroutine psorgrq. to use q to update another matrix, use scalapack subroutine psormrq the matrix z is represented as a product of elementary reflectors pslacp2 copies all or part of a distributed matrix a to another performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pslacpy copies all or part of a distributed matrix a to another performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pslamr1d redistributes a one-dimensional row vector from one data decomposition to another this is an auxiliary routine called by pssytrd to redistribute d, e work (local workspace) real dimension (lwork) used to hold the buffers sent from one process to another lwork (local input) integer size of work array work (local workspace) real dimension (lwork) used to hold the buffers sent from one process to another lwork (local input) integer size of work array to form q explicitly, use scalapack subroutine pzungqr. to use q to update another matrix, use scalapack subroutine pzunmqr the matrix z is represented as a product of elementary reflectors to form q explicitly, use scalapack subroutine pzungrq. to use q to update another matrix, use scalapack subroutine pzunmrq the matrix z is represented as a product of elementary reflectors pzlacp2 copies all or part of a distributed matrix a to another performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pzlacpy copies all or part of a distributed matrix a to another performs a local copy sub( a ) := sub( b ), where sub( a ) denotes pzlamr1d redistributes a one-dimensional row vector from one data decomposition to another this is an auxiliary routine called by pzhetrd to redistribute d, e size) this holds the size 3 reflectors one after another and thi vecs (global input) complex*16 array of size 3*n (matrix size) this holds the size 3 reflectors one after another and thi |
| answer answer being operated on. let x be a generic term for the input vector(s). then, the processes which receive the answer will be (note that i ceive the result will be the union of the following calculation for being operated on. let x be a generic term for the input vector(s). then, the processes which receive the answer will be (note that i ceive the result will be the union of the following calculation for being operated on. let x be a generic term for the input vector(s). then, the processes which receive the answer will be (note that i ceive the result will be the union of the following calculation for being operated on. let x be a generic term for the input vector(s). then, the processes which receive the answer will be (note that i ceive the result will be the union of the following calculation for |
| anticipation anticipation pjlaenv is patterned after ilaenv and keeps the same interface in anticipation of future needs, even though pjlaenv is only sparsel data layout blocking factor as the algorithmic blocking factor - |
| any any 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 currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer the last processor does not need to send anything currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distribute such a global array has an associated description vector desca. let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer the last processor does not need to send anything currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as 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 let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distribute such a global array has an associated description vector desca. let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer the last processor does not need to send anything currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as 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 let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distribute such a global array has an associated description vector desca. let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer the last processor does not need to send anything currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as different processes. because of this, it is possible that a heterogeneous system may return incorrect results without any erro let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distribute such a global array has an associated description vector desca. let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c currently, only algorithms designed for the case n/p >> bw are implemented. these go by many names, including divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as let a be a generic term for any 2d block cyclicly distributed array in the following comments, the character _ should be read as 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 |
| anything anything the last processor does not need to send anything the last processor does not need to send anything the last processor does not need to send anything the last processor does not need to send anything |
| apart apart element (l,ln+1) is swapped with element (j,ln+1) etc furthermore, the elements in the same row are ldb=llda-1 apart data format: element (l,ln+1) is swapped with element (j,ln+1) etc furthermore, the elements in the same row are ldb=llda-1 apart data format: element (l,ln+1) is swapped with element (j,ln+1) etc furthermore, the elements in the same row are ldb=llda-1 apart data format: element (l,ln+1) is swapped with element (j,ln+1) etc furthermore, the elements in the same row are ldb=llda-1 apart data format: |
| appear appear 1) opts is a concatenation of all of the character options to subroutine name, in the same order that they appear in th the value of the parameter specified by ispec. |
| application application clahqr used to have a single row application and a singl more clever. we break each transformation down into 3 process columns in sc. the duplication of information simplifies greatly the application of the factors notes dlahqr used to have a single row application and a singl more clever. we break each transformation down into 3 process columns in sc. the duplication of information simplifies greatly the application of the factors notes slahqr used to have a single row application and a singl more clever. we break each transformation down into 3 process columns in sc. the duplication of information simplifies greatly the application of the factors notes zlahqr used to have a single row application and a singl more clever. we break each transformation down into 3 process columns in sc. the duplication of information simplifies greatly the application of the factors notes |
| applications applications reference: n.j. higham, "fortran codes for estimating the one-norm of a real or complex matrix, with applications to condition estimation" reference: n.j. higham, "fortran codes for estimating the one-norm of a real or complex matrix, with applications to condition estimation" reference: n.j. higham, "fortran codes for estimating the one-norm of a real or complex matrix, with applications to condition estimation" reference: n.j. higham, "fortran codes for estimating the one-norm of a real or complex matrix, with applications to condition estimation" |
| applied applied 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 the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering 5. iterative refinement is applied to improve the computed solutio for it. 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 matrix a. this routine will transpose the pivot vector if necessary. for example if the row pivots should be applied to the columns o direc (global input) character specifies in which order the permutation is applied computes p * sub( a ); direc (global input) character specifies in which order the permutation is applied = 'b' (backward) the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering 5. iterative refinement is applied to improve the computed solutio for it. the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering let nq = m if side = 'l' and nq = n if side = 'r'. thus nq is the order of the unitary matrix q or p**h that is applied if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by-k the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering 5. iterative refinement is applied to improve the computed solutio for it. 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 matrix a. this routine will transpose the pivot vector if necessary. for example if the row pivots should be applied to the columns o direc (global input) character specifies in which order the permutation is applied computes p * sub( a ); direc (global input) character specifies in which order the permutation is applied = 'b' (backward) let nq = m if side = 'l' and nq = n if side = 'r'. thus nq is the order of the orthogonal matrix q or p**t that is applied if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by-k the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering 5. iterative refinement is applied to improve the computed solutio for it. the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering 5. iterative refinement is applied to improve the computed solutio for it. 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 matrix a. this routine will transpose the pivot vector if necessary. for example if the row pivots should be applied to the columns o direc (global input) character specifies in which order the permutation is applied computes p * sub( a ); direc (global input) character specifies in which order the permutation is applied = 'b' (backward) let nq = m if side = 'l' and nq = n if side = 'r'. thus nq is the order of the orthogonal matrix q or p**t that is applied if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by-k the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering 5. iterative refinement is applied to improve the computed solutio for it. the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering 5. iterative refinement is applied to improve the computed solutio for it. 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 matrix a. this routine will transpose the pivot vector if necessary. for example if the row pivots should be applied to the columns o direc (global input) character specifies in which order the permutation is applied computes p * sub( a ); direc (global input) character specifies in which order the permutation is applied = 'b' (backward) the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering 5. iterative refinement is applied to improve the computed solutio for it. the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering the individual pieces are factored independently and in parallel. these factors are applied to the matrix creatin space af. mathematically, this is equivalent to reordering let nq = m if side = 'l' and nq = n if side = 'r'. thus nq is the order of the unitary matrix q or p**h that is applied if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by-k 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 |
| applies applies the first iteration of this loop determines a reflection g from the vector v and applies it from left and right to h claref applies one or several householder reflectors of size rows or columns. dlaref applies one or several householder reflectors of size rows or columns. pclapiv applies either p (permutation matrix indicated by ipiv sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pclapv2 applies either p (permutation matrix indicated by ipiv a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pclarfb applies a complex block reflector q or its conjugat denoting c(ic:ic+m-1,jc:jc+n-1), from the left or the right. pclarzb applies a complex block reflector q or its conjugat denoting c(ic:ic+m-1,jc:jc+n-1), from the left or the right. pdlapiv applies either p (permutation matrix indicated by ipiv sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pdlapv2 applies either p (permutation matrix indicated by ipiv a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pdlarfb applies a real block reflector q or its transpose q**t to from the left or the right. pdlarzb applies a real block reflector q or its transpose q**t t from the left or the right. pslapiv applies either p (permutation matrix indicated by ipiv sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pslapv2 applies either p (permutation matrix indicated by ipiv a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pslarfb applies a real block reflector q or its transpose q**t to from the left or the right. pslarzb applies a real block reflector q or its transpose q**t t from the left or the right. pzlapiv applies either p (permutation matrix indicated by ipiv sub( a ) = a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pzlapv2 applies either p (permutation matrix indicated by ipiv a(ia:ia+m-1,ja:ja+n-1), resulting in row or column pivoting. the pzlarfb applies a complex block reflector q or its conjugat denoting c(ic:ic+m-1,jc:jc+n-1), from the left or the right. pzlarzb applies a complex block reflector q or its conjugat denoting c(ic:ic+m-1,jc:jc+n-1), from the left or the right. slaref applies one or several householder reflectors of size rows or columns. the first iteration of this loop determines a reflection g from the vector v and applies it from left and right to h zlaref applies one or several householder reflectors of size rows or columns. |
| Apply Apply on exit, the data is rearranged in the best order for Applying lds (local input) integer type (global input) character*1 if 'r': Apply reflectors to the rows of the matri otherwise: apply reflectors to the columns of the matrix if eigenvectors are desired, then Apply saved rotations on exit, the data is rearranged in the best order for Applying lds (local input) integer type (global input) character*1 if 'r': Apply reflectors to the rows of the matri otherwise: apply reflectors to the columns of the matrix if eigenvectors are desired, then Apply saved rotations Apply factorization to lower connection block bl_ apply factorization to upper connection block bu_i Apply factorization to lower connection block bl_ 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 elements of the vectors v together form the (n-k+1)-by-nb matrix v which is needed, with t and y, to Apply the transformation to th a(ia:ia+n-1,ja:ja+n-k) := (i-v*t*v')*(a(ia:ia+n-1,ja:ja+n-k)-y*v'). the following restrictions Apply when ipiv must be transposed descip(mb_) must equal desca(nb_) side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left q' * sub( a ) * q, and returns the matrices v and w which are needed to Apply the transformation to the unreduced part of sub( a ) if uplo = 'u', pclatrd reduces the last nb rows and columns of a Apply factorization to odd-even connection block b_ conjugate transpose the connection block in preparation. Apply factorization to odd-even connection block b_ side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left vect (global input) character = 'q': Apply q or q**h side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left Apply factorization to lower connection block bl_ apply factorization to upper connection block bu_i Apply factorization to lower connection block bl_ 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 elements of the vectors v together form the (n-k+1)-by-nb matrix v which is needed, with t and y, to Apply the transformation to th a(ia:ia+n-1,ja:ja+n-k) := (i-v*t*v')*(a(ia:ia+n-1,ja:ja+n-k)-y*v'). the following restrictions Apply when ipiv must be transposed descip(mb_) must equal desca(nb_) side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left form by an orthogonal similarity transformation q' * sub( a ) * q, and returns the matrices v and w which are needed to Apply th side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left vect (global input) character = 'q': Apply q or q**t side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left Apply factorization to odd-even connection block b_ transpose the connection block in preparation. Apply factorization to odd-even connection block b_ Apply factorization to lower connection block bl_ apply factorization to upper connection block bu_i Apply factorization to lower connection block bl_ 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 elements of the vectors v together form the (n-k+1)-by-nb matrix v which is needed, with t and y, to Apply the transformation to th a(ia:ia+n-1,ja:ja+n-k) := (i-v*t*v')*(a(ia:ia+n-1,ja:ja+n-k)-y*v'). the following restrictions Apply when ipiv must be transposed descip(mb_) must equal desca(nb_) side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left form by an orthogonal similarity transformation q' * sub( a ) * q, and returns the matrices v and w which are needed to Apply th side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left vect (global input) character = 'q': Apply q or q**t side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left side (global input) character = 'l': Apply q or q**t from the left Apply factorization to odd-even connection block b_ transpose the connection block in preparation. Apply factorization to odd-even connection block b_ Apply factorization to lower connection block bl_ apply factorization to upper connection block bu_i Apply factorization to lower connection block bl_ 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 elements of the vectors v together form the (n-k+1)-by-nb matrix v which is needed, with t and y, to Apply the transformation to th a(ia:ia+n-1,ja:ja+n-k) := (i-v*t*v')*(a(ia:ia+n-1,ja:ja+n-k)-y*v'). the following restrictions Apply when ipiv must be transposed descip(mb_) must equal desca(nb_) side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left q' * sub( a ) * q, and returns the matrices v and w which are needed to Apply the transformation to the unreduced part of sub( a ) if uplo = 'u', pzlatrd reduces the last nb rows and columns of a Apply factorization to odd-even connection block b_ conjugate transpose the connection block in preparation. Apply factorization to odd-even connection block b_ side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left vect (global input) character = 'q': Apply q or q**h side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left side (global input) character = 'l': Apply q or q**h from the left on exit, the data is rearranged in the best order for Applying lds (local input) integer type (global input) character*1 if 'r': Apply reflectors to the rows of the matri otherwise: apply reflectors to the columns of the matrix if eigenvectors are desired, then Apply saved rotations on exit, the data is rearranged in the best order for Applying lds (local input) integer type (global input) character*1 if 'r': Apply reflectors to the rows of the matri otherwise: apply reflectors to the columns of the matrix if eigenvectors are desired, then Apply saved rotations |
| applying applying on exit, the data is rearranged in the best order for applying lds (local input) integer on exit, the data is rearranged in the best order for applying lds (local input) integer on exit, the data is rearranged in the best order for applying lds (local input) integer on exit, the data is rearranged in the best order for applying lds (local input) integer |
| appropriate appropriate proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; to a system which does not have ieee 754 arithmetic, modify the appropriate slmake.inc file to include the compiler switc encourage to call pchetrd which will then call pchettrd if appropriate. a must be in cyclic format (i.e. mb = nb = 1) only lower triangular storage is supported. proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; values in d, w, and rho, between 1 and k. it makes the appropriate calls to slaed this code makes very mild assumptions about floating point proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer to a system which does not have ieee 754 arithmetic, modify the appropriate slmake.inc file to include the compiler switc encourage to call pdsytrd which will then call pdhettrd if appropriate. a must be in cyclic format (i.e. mb = nb = 1) only lower triangular storage is supported. proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; values in d, w, and rho, between 1 and k. it makes the appropriate calls to slaed this code makes very mild assumptions about floating point proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer to a system which does not have ieee 754 arithmetic, modify the appropriate slmake.inc file to include the compiler switc encourage to call pssytrd which will then call pshettrd if appropriate. a must be in cyclic format (i.e. mb = nb = 1) only lower triangular storage is supported. proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; to a system which does not have ieee 754 arithmetic, modify the appropriate slmake.inc file to include the compiler switc encourage to call pzhetrd which will then call pzhettrd if appropriate. a must be in cyclic format (i.e. mb = nb = 1) only lower triangular storage is supported. proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; proper orientation: if the appropriate one-dimensional descriptor is dtypea=50 have a ctxt value that refers to a 1 by p blacs grid; for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer for tridiagonal matrices, it is obvious: n/p >> bw(=1), and so d&c algorithms are the appropriate choice algorithm description: divide and conquer |
| approximate approximate the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to the absolute error tolerance for the eigenvalues. an approximate eigenvalue is accepted as converge of width less than or equal to |
| approximation approximation fails to converge, then that column of z contains the latest approximation to the eigenvector, and the index of th if jobz = 'n', then z is not referenced. fails to converge, then that column of z contains the latest approximation to the eigenvector, and the index of th if jobz = 'n', then z is not referenced. fails to converge, then that column of z contains the latest approximation to the eigenvector, and the index of th if jobz = 'n', then z is not referenced. fails to converge, then that column of z contains the latest approximation to the eigenvector, and the index of th if jobz = 'n', then z is not referenced. fails to converge, then that column of z contains the latest approximation to the eigenvector, and the index of th if jobz = 'n', then z is not referenced. fails to converge, then that column of z contains the latest approximation to the eigenvector, and the index of th if jobz = 'n', then z is not referenced. fails to converge, then that column of z contains the latest approximation to the eigenvector, and the index of th if jobz = 'n', then z is not referenced. fails to converge, then that column of z contains the latest approximation to the eigenvector, and the index of th if jobz = 'n', then z is not referenced. |
| April April these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same these are alignment restrictions that may or may not be removed in future releases. -andy cleary, April 14, 1996 block sizes must be the same |
| APTR APTR is nr+bwu where nr is the number of columns on the last processor finally APTR is the pointer to the first element of a. as lapac has to be adjusted on processor mycol=0. is nr+bwu where nr is the number of columns on the last processor finally APTR is the pointer to the first element of a. as lapac has to be adjusted on processor mycol=0. is nr+bwu where nr is the number of columns on the last processor finally APTR is the pointer to the first element of a. as lapac has to be adjusted on processor mycol=0. is nr+bwu where nr is the number of columns on the last processor finally APTR is the pointer to the first element of a. as lapac has to be adjusted on processor mycol=0. |
| Arbenz Arbenz and marbwus hegland, australian natonal university. feb., 1997. based on code written by : peter Arbenz, eth zurich, 1996 ===================================================================== and markus hegland, australian national university. feb., 1997. based on code written by : peter Arbenz, eth zurich, 1996 eth, zurich. and markus hegland, australian national university. feb., 1997. based on code written by : peter Arbenz, eth zurich, 1996 eth, zurich. and marbwus hegland, australian natonal university. feb., 1997. based on code written by : peter Arbenz, eth zurich, 1996 ===================================================================== |
| Architectures Architectures conquer algorithm for the symmetric eigenvalue problem on distributed memory Architectures" (see also lapack working note 132) conquer algorithm for the symmetric eigenvalue problem on distributed memory Architectures" (see also lapack working note 132) conquer algorithm for the symmetric eigenvalue problem on distributed memory Architectures" (see also lapack working note 132) conquer algorithm for the symmetric eigenvalue problem on distributed memory Architectures" (see also lapack working note 132) conquer algorithm for the symmetric eigenvalue problem on distributed memory Architectures" (see also lapack working note 132) conquer algorithm for the symmetric eigenvalue problem on distributed memory Architectures" (see also lapack working note 132) |
| are are rows 1 to kl+ku+1, and the multipliers used during the factorization are stored in rows kl+ku+2 to 2*kl+ku+1 which is about to be factorized. the number of rows in the partitioning are jb, i2, i3 respectively, and the number and the subdiagonal elements of a31 lie outside the band. i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. clamsh sends multiple shifts through a small (single node) matrix to see how consecutive small subdiagonal elements are modified b that can be sent through. on entry, the elements of the input matrix. on exit, they are overwritten by the elements of th = 'l': e is the subdiagonal of l, and a = l*d*l'. (the two forms are equivalent if a is real. trans (input) character if eigenvectors are desired, then save rotations rows 1 to kl+ku+1, and the multipliers used during the factorization are stored in rows kl+ku+2 to 2*kl+ku+1 which is about to be factorized. the number of rows in the partitioning are jb, i2, i3 respectively, and the number and the subdiagonal elements of a31 lie outside the band. dlamsh sends multiple shifts through a small (single node) matrix to see how consecutive small subdiagonal elements are modified b that can be sent through. dlasorte sorts eigenpairs so that real eigenpairs are together an since every 2nd subdiagonal is guaranteed to be zero. if eigenvalues j and j-1 are too close, add a relativel if eigenvectors are desired, then save rotations of the factorization. note that permutations are performed on the matrix, so tha by lapack. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove of the factorization. note that permutations are performed on the matrix, so tha by lapack. prepare output: set info = 0 if no error, and divide by descmul the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) are below the diagonal, with the array tauq, represent the general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) are below the diagonal, with the array tauq, represent the from the factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u; the unit diagonal elements of l are not stored ia (global input) integer r(i) and c(j) are restricted to be between smlnum = smallest saf factors is not guaranteed to reduce the condition number of general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) are ments below the first subdiagonal, with the array tau, repre- general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) are ments below the first subdiagonal, with the array tau, repre- and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. the following options are provided 1. if trans = 'n' and m >= n: find the least squares solution of and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed matrix and x and sub( b ) = b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrh v is an n-by-n orthogonal matrix. the diagonal elements of sigma are the singular values of a and the columns of u and v are th singular values are returned in array s in decreasing order and where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x and b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs matrices error bounds on the solution and a condition estimate are also this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc ments (lower trapezoidal if m > n), and u is upper triangular (upper trapezoidal if m < n). l and u are stored in sub( a ) this is the right-looking parallel level 3 blas version of the this routine requires square block data decomposition ( mb_a=nb_a ) arguments in particular, if sub( b ) is square and nonsingular, the gq factorization of inv( sub( b ) )* sub( a ): in particular, if sub( b ) is square and nonsingular, the gr factorization of sub( a )*inv( sub( b ) ): on output, work(1) returns the workspace needed to guarantee completion. if the input parameters are incorrect, work(1 lwork (local input) integer if eigenvectors are requested with np0 = numroc( max( n, nb, 2 ), nb, 0, 0, nprow ) total number of eigenvectors computed. 0 <= nz <= m. the number of columns of z that are filled if jobz .eq. 'v', nz = m unless the user supplies uplo (global input) character*1 = 'u': upper triangles of sub( a ) and sub( b ) are stored pchengst performs the same function as pchegst, but is based on rank 2k updates, which are faster and more scalable tha the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowe documented below. (search for "restrictions".) triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, 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 global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x pclacon estimates the 1-norm of a square, complex distributed matri products. x and v are aligned with the distributed matrix a, this h43h34 (global input) complex these three values are for the double shift qr iteration buf (local output) complex array of size lwork. pclaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. n-by-(n-k+1) distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction i routine returns the matrices v and t which determine q as a block i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. normi denotes the infinity norm of a matrix (maximum row sum) and normf denotes the frobenius norm of a matrix (square root of sum o the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below are to as colsums. infinity-norm = 1-norm = rowsums+colsums. the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below are to as colsums. infinity-norm = 1-norm = rowsums+colsums. rowcol (global input) character*1 specifies if the rows or columns are to be permuted = 'c' columns will be permuted. rowcol (global input) character specifies if the rows or columns are to be permuted = 'c' columns will be permuted. large and small are threshold values used to decide if row scalin element. if amax > large or amax < small, row scaling is done. large and small are threshold values used to decide if scaling shoul if amax > large or amax < small, scaling is done. indicates how the vectors which define the elementary reflectors are stored = 'r': rowwise if the elements of sub( x ) are all zero and x(iax,jax) is real direct (global input) character*1 specifies the order in which the elementary reflectors are = 'f': h = h(1) h(2) . . . h(k) (forward) currently, only storev = 'r' and direct = 'b' are supported notes currently, only storev = 'r' and direct = 'b' are supported notes alpha (global input) complex the constant to which the offdiagonal elements are to b alpha (global input) complex the constant to which the offdiagonal elements are to b scale and sumsq must be supplied in scale and sumsq respectively. scale and sumsq are overwritten by scl and ssq respectively the routine makes only one pass through the vector sub( x ). rowcol (global input) character specifies if the rows or columns are permuted = 'c' (columns) tridiagonal form by an unitary similarity transformation q' * sub( a ) * q, and returns the matrices v and w which are and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. scale x so that its components are less than or equal t h43h34 (global input) complex these three values are for the double shift qr iteration the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x of the factorization. note that permutations are performed on the matrix, so tha by lapack. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove the scaling factor are stored along process rows in sr and alon greatly the application of the factors. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), hermitian distributed positive definite matrix and x and sub( b ) denoting b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs distribute where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x and b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs matrices error bounds on the solution and a condition estimate are also the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== correspond to user specified eigenvalues. pcstein does not orthogonalize vectors that are on different processes. the exten eigenvectors that are to be orthogonalized are computed by the same upper triangular part is not referenced. if diag = 'u', the diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also no the right eigenvector x and the left eigenvector y of t corresponding to an eigenvalue w are defined by t*x = w*x, y'*t = w*y' referenced. if diag = 'u', the diagonal elements of sub( a ) are als of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assume matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. here q and p**h are the unitary distributed matrices determined b bidiagonal form: a(ia:*,ja:*) = q * b * p**h. q and p**h are defined if side = 'r', 1 <= ilo <= ihi <= max(1,n); ilo and ihi are relative indexes a (local input) complex pointer into the local memory ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. of the factorization. note that permutations are performed on the matrix, so tha by lapack. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove of the factorization. note that permutations are performed on the matrix, so tha by lapack. prepare output: set info = 0 if no error, and divide by descmul the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) are below the diagonal, with the array tauq, represent the general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) are below the diagonal, with the array tauq, represent the from the factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u; the unit diagonal elements of l are not stored ia (global input) integer r(i) and c(j) are restricted to be between smlnum = smallest saf factors is not guaranteed to reduce the condition number of general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) are ments below the first subdiagonal, with the array tau, repre- general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) are ments below the first subdiagonal, with the array tau, repre- and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. the following options are provided 1. if trans = 'n' and m >= n: find the least squares solution of and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed matrix and x and sub( b ) = b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrh v is an n-by-n orthogonal matrix. the diagonal elements of sigma are the singular values of a and the columns of u and v are th singular values are returned in array s in decreasing order and where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x and b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs matrices error bounds on the solution and a condition estimate are also this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc ments (lower trapezoidal if m > n), and u is upper triangular (upper trapezoidal if m < n). l and u are stored in sub( a ) this is the right-looking parallel level 3 blas version of the this routine requires square block data decomposition ( mb_a=nb_a ) arguments in particular, if sub( b ) is square and nonsingular, the gq factorization of inv( sub( b ) )* sub( a ): in particular, if sub( b ) is square and nonsingular, the gr factorization of sub( a )*inv( sub( b ) ): or lower bidiagonal form by an orthogonal transformation q' * a * p, and returns the matrices x and y which are needed to apply th pdlacon estimates the 1-norm of a square, real distributed matrix a x and v are aligned with the distributed matrix a, this information h43h34 (global input) double precision these three values are for the double shift qr iteration buf (local output) double precision array of size lwork. this is a scalapack internal subroutine and arguments are no this is a scalapack internal procedure and arguments are not checke the eigenvectors of the original matrix are stored in q, and th 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 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 pdlaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction is performed by an orthogo matrices v and t which determine q as a block reflector i - v*t*v', i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. normi denotes the infinity norm of a matrix (maximum row sum) and normf denotes the frobenius norm of a matrix (square root of sum o the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below are to as colsums. infinity-norm = 1-norm = rowsums+colsums. this is a scalapack internal procedure and arguments are not checke rowcol (global input) character*1 specifies if the rows or columns are to be permuted = 'c' columns will be permuted. rowcol (global input) character specifies if the rows or columns are to be permuted = 'c' columns will be permuted. large and small are threshold values used to decide if row scalin element. if amax > large or amax < small, row scaling is done. large and small are threshold values used to decide if scaling shoul if amax > large or amax < small, scaling is done. pdlared1d redistributes a 1d arra it assumes that the input array, bycol, is distributed across pdlared2d redistributes a 1d arra it assumes that the input array, byrow, is distributed across indicates how the vectors which define the elementary reflectors are stored = 'r': rowwise if the elements of sub( x ) are all zero, then tau = 0 and h i direct (global input) character*1 specifies the order in which the elementary reflectors are = 'f': h = h(1) h(2) . . . h(k) (forward) currently, only storev = 'r' and direct = 'b' are supported notes currently, only storev = 'r' and direct = 'b' are supported notes alpha (global input) double precision the constant to which the offdiagonal elements are to b alpha (global input) double precision the constant to which the offdiagonal elements are to b d (global input/output) double precision array, dimmension (n) on exit, the number in d are sorted in increasing order q (local input) double precision pointer into the local memory scale and sumsq must be supplied in scale and sumsq respectively. scale and sumsq are overwritten by scl and ssq respectively the routine makes only one pass through the vector sub( x ). rowcol (global input) character specifies if the rows or columns are permuted = 'c' (columns) form by an orthogonal similarity transformation q' * sub( a ) * q, and returns the matrices v and w which are needed to apply th and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. h43h34 (global input) double precision these three values are for the double shift qr iteration indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. here q and p**t are the orthogonal distributed matrices determined b bidiagonal form: a(ia:*,ja:*) = q * b * p**t. q and p**t are defined if side = 'r', 1 <= ilo <= ihi <= max(1,n); ilo and ihi are relative indexes a (local input) double precision pointer into the local memory ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. of the factorization. note that permutations are performed on the matrix, so tha by lapack. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove the scaling factor are stored along process rows in sr and alon greatly the application of the factors. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), symmetric distributed positive definite matrix and x and sub( b ) denoting b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs distribute where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x and b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs matrices error bounds on the solution and a condition estimate are also the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== to 1 (in slmake.inc). the features of ieee arithmetic that are needed for the "fast" sturm count are : (a) infinit point number is assumed be in the 32nd bit position correspond to user specified eigenvalues. pdstein does not orthogonalize vectors that are on different processes. the exten eigenvectors that are to be orthogonalized are computed by the same needed to guarantee completion. if the input parameters are incorrect, work(1) may also b total number of eigenvectors computed. 0 <= nz <= m. the number of columns of z that are filled if jobz .eq. 'v', nz = m unless the user supplies uplo (global input) character*1 = 'u': upper triangles of sub( a ) and sub( b ) are stored pdsyngst performs the same function as pdhegst, but is based on rank 2k updates, which are faster and more scalable tha the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowe documented below. (search for "restrictions".) triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, upper triangular part is not referenced. if diag = 'u', the diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also no referenced. if diag = 'u', the diagonal elements of sub( a ) are als of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assume matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== but not optimal, performance on many of the currently available computers. users are encouraged to modify this subroutine to se and problem size information in the arguments. the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== of the factorization. note that permutations are performed on the matrix, so tha by lapack. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove of the factorization. note that permutations are performed on the matrix, so tha by lapack. prepare output: set info = 0 if no error, and divide by descmul the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) are below the diagonal, with the array tauq, represent the general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) are below the diagonal, with the array tauq, represent the from the factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u; the unit diagonal elements of l are not stored ia (global input) integer r(i) and c(j) are restricted to be between smlnum = smallest saf factors is not guaranteed to reduce the condition number of general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) are ments below the first subdiagonal, with the array tau, repre- general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) are ments below the first subdiagonal, with the array tau, repre- and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. the following options are provided 1. if trans = 'n' and m >= n: find the least squares solution of and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed matrix and x and sub( b ) = b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrh v is an n-by-n orthogonal matrix. the diagonal elements of sigma are the singular values of a and the columns of u and v are th singular values are returned in array s in decreasing order and where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x and b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs matrices error bounds on the solution and a condition estimate are also this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc ments (lower trapezoidal if m > n), and u is upper triangular (upper trapezoidal if m < n). l and u are stored in sub( a ) this is the right-looking parallel level 3 blas version of the this routine requires square block data decomposition ( mb_a=nb_a ) arguments in particular, if sub( b ) is square and nonsingular, the gq factorization of inv( sub( b ) )* sub( a ): in particular, if sub( b ) is square and nonsingular, the gr factorization of sub( a )*inv( sub( b ) ): or lower bidiagonal form by an orthogonal transformation q' * a * p, and returns the matrices x and y which are needed to apply th pslacon estimates the 1-norm of a square, real distributed matrix a x and v are aligned with the distributed matrix a, this information h43h34 (global input) real these three values are for the double shift qr iteration buf (local output) real array of size lwork. this is a scalapack internal subroutine and arguments are no this is a scalapack internal procedure and arguments are not checke the eigenvectors of the original matrix are stored in q, and th 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 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 pslaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction is performed by an orthogo matrices v and t which determine q as a block reflector i - v*t*v', i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. normi denotes the infinity norm of a matrix (maximum row sum) and normf denotes the frobenius norm of a matrix (square root of sum o the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below are to as colsums. infinity-norm = 1-norm = rowsums+colsums. this is a scalapack internal procedure and arguments are not checke rowcol (global input) character*1 specifies if the rows or columns are to be permuted = 'c' columns will be permuted. rowcol (global input) character specifies if the rows or columns are to be permuted = 'c' columns will be permuted. large and small are threshold values used to decide if row scalin element. if amax > large or amax < small, row scaling is done. large and small are threshold values used to decide if scaling shoul if amax > large or amax < small, scaling is done. pslared1d redistributes a 1d arra it assumes that the input array, bycol, is distributed across pslared2d redistributes a 1d arra it assumes that the input array, byrow, is distributed across indicates how the vectors which define the elementary reflectors are stored = 'r': rowwise if the elements of sub( x ) are all zero, then tau = 0 and h i direct (global input) character*1 specifies the order in which the elementary reflectors are = 'f': h = h(1) h(2) . . . h(k) (forward) currently, only storev = 'r' and direct = 'b' are supported notes currently, only storev = 'r' and direct = 'b' are supported notes alpha (global input) real the constant to which the offdiagonal elements are to b alpha (global input) real the constant to which the offdiagonal elements are to b d (global input/output) real array, dimmension (n) on exit, the number in d are sorted in increasing order q (local input) real pointer into the local memory scale and sumsq must be supplied in scale and sumsq respectively. scale and sumsq are overwritten by scl and ssq respectively the routine makes only one pass through the vector sub( x ). rowcol (global input) character specifies if the rows or columns are permuted = 'c' (columns) form by an orthogonal similarity transformation q' * sub( a ) * q, and returns the matrices v and w which are needed to apply th and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. h43h34 (global input) real these three values are for the double shift qr iteration indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. here q and p**t are the orthogonal distributed matrices determined b bidiagonal form: a(ia:*,ja:*) = q * b * p**t. q and p**t are defined if side = 'r', 1 <= ilo <= ihi <= max(1,n); ilo and ihi are relative indexes a (local input) real pointer into the local memory ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. of the factorization. note that permutations are performed on the matrix, so tha by lapack. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove the scaling factor are stored along process rows in sr and alon greatly the application of the factors. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), symmetric distributed positive definite matrix and x and sub( b ) denoting b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs distribute where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x and b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs matrices error bounds on the solution and a condition estimate are also the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== to 1 (in slmake.inc). the features of ieee arithmetic that are needed for the "fast" sturm count are : (a) infinit point number is assumed be in the 32nd or 64th bit position correspond to user specified eigenvalues. psstein does not orthogonalize vectors that are on different processes. the exten eigenvectors that are to be orthogonalized are computed by the same needed to guarantee completion. if the input parameters are incorrect, work(1) may also b total number of eigenvectors computed. 0 <= nz <= m. the number of columns of z that are filled if jobz .eq. 'v', nz = m unless the user supplies uplo (global input) character*1 = 'u': upper triangles of sub( a ) and sub( b ) are stored pssyngst performs the same function as pshegst, but is based on rank 2k updates, which are faster and more scalable tha the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowe documented below. (search for "restrictions".) triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, upper triangular part is not referenced. if diag = 'u', the diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also no referenced. if diag = 'u', the diagonal elements of sub( a ) are als of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assume matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. of the factorization. note that permutations are performed on the matrix, so tha by lapack. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x ===================================================================== the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove of the factorization. note that permutations are performed on the matrix, so tha by lapack. prepare output: set info = 0 if no error, and divide by descmul the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) are below the diagonal, with the array tauq, represent the general distributed matrix sub( a ). on exit, if m >= n, the diagonal and the first superdiagonal of sub( a ) are below the diagonal, with the array tauq, represent the from the factorization a(ia:ia+n-1,ja:ja+n-1) = p*l*u; the unit diagonal elements of l are not stored ia (global input) integer r(i) and c(j) are restricted to be between smlnum = smallest saf factors is not guaranteed to reduce the condition number of general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) are ments below the first subdiagonal, with the array tau, repre- general distributed matrix sub( a ) to be reduced. on exit, the upper triangle and the first subdiagonal of sub( a ) are ments below the first subdiagonal, with the array tau, repre- and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. the following options are provided 1. if trans = 'n' and m >= n: find the least squares solution of and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. where sub( a ) = a(ia:ia+n-1,ja:ja+n-1) is an n-by-n distributed matrix and x and sub( b ) = b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrh v is an n-by-n orthogonal matrix. the diagonal elements of sigma are the singular values of a and the columns of u and v are th singular values are returned in array s in decreasing order and where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x and b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs matrices error bounds on the solution and a condition estimate are also this routine requires n <= nb_a-mod(ja-1, nb_a) and square bloc ments (lower trapezoidal if m > n), and u is upper triangular (upper trapezoidal if m < n). l and u are stored in sub( a ) this is the right-looking parallel level 3 blas version of the this routine requires square block data decomposition ( mb_a=nb_a ) arguments in particular, if sub( b ) is square and nonsingular, the gq factorization of inv( sub( b ) )* sub( a ): in particular, if sub( b ) is square and nonsingular, the gr factorization of sub( a )*inv( sub( b ) ): on output, work(1) returns the workspace needed to guarantee completion. if the input parameters are incorrect, work(1 lwork (local input) integer if eigenvectors are requested with np0 = numroc( max( n, nb, 2 ), nb, 0, 0, nprow ) total number of eigenvectors computed. 0 <= nz <= m. the number of columns of z that are filled if jobz .eq. 'v', nz = m unless the user supplies uplo (global input) character*1 = 'u': upper triangles of sub( a ) and sub( b ) are stored pzhengst performs the same function as pzhegst, but is based on rank 2k updates, which are faster and more scalable tha the tailored codes place no restrictions on ia, ja, mb or nb. at present, ia, ja, mb and nb are restricted to those values allowe documented below. (search for "restrictions".) triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, triangular part is not referenced. on exit, if uplo = 'u', the diagonal and first superdiagonal of sub( a ) are over matrix t, and the elements above the first superdiagonal, 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 global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x pzlacon estimates the 1-norm of a square, complex distributed matri products. x and v are aligned with the distributed matrix a, this h43h34 (global input) complex*16 these three values are for the double shift qr iteration buf (local output) complex*16 array of size lwork. pzlaevswp moves the eigenvectors (potentially unsorted) from where they are computed, to a scalapack standard block cycli i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. n-by-(n-k+1) distributed matrix a(ia:ia+n-1,ja:ja+n-k) so that elements below the k-th subdiagonal are zero. the reduction i routine returns the matrices v and t which determine q as a block i am not sure that this works correctly when ib and jb are not equa with 1 used in its place. normi denotes the infinity norm of a matrix (maximum row sum) and normf denotes the frobenius norm of a matrix (square root of sum o the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below are to as colsums. infinity-norm = 1-norm = rowsums+colsums. the point of reflection. the pictures below demonstrate this. in the following code, the row sums created by --- rows below are to as colsums. infinity-norm = 1-norm = rowsums+colsums. rowcol (global input) character*1 specifies if the rows or columns are to be permuted = 'c' columns will be permuted. rowcol (global input) character specifies if the rows or columns are to be permuted = 'c' columns will be permuted. large and small are threshold values used to decide if row scalin element. if amax > large or amax < small, row scaling is done. large and small are threshold values used to decide if scaling shoul if amax > large or amax < small, scaling is done. indicates how the vectors which define the elementary reflectors are stored = 'r': rowwise if the elements of sub( x ) are all zero and x(iax,jax) is real direct (global input) character*1 specifies the order in which the elementary reflectors are = 'f': h = h(1) h(2) . . . h(k) (forward) currently, only storev = 'r' and direct = 'b' are supported notes currently, only storev = 'r' and direct = 'b' are supported notes alpha (global input) complex*16 the constant to which the offdiagonal elements are to b alpha (global input) complex*16 the constant to which the offdiagonal elements are to b scale and sumsq must be supplied in scale and sumsq respectively. scale and sumsq are overwritten by scl and ssq respectively the routine makes only one pass through the vector sub( x ). rowcol (global input) character specifies if the rows or columns are permuted = 'c' (columns) tridiagonal form by an unitary similarity transformation q' * sub( a ) * q, and returns the matrices v and w which are and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. scale x so that its components are less than or equal t h43h34 (global input) complex*16 these three values are for the double shift qr iteration the global increment for the elements of x. only two values of incx are supported in this version, namely 1 and m_x of the factorization. note that permutations are performed on the matrix, so tha by lapack. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove the scaling factor are stored along process rows in sr and alon greatly the application of the factors. same processes. these conditions ensure that sub( a ) and sub( af ) (resp. sub( x ) and sub( b ) ) are "perfectly" aligned moreover, this routine requires the distributed submatrices sub( a ), hermitian distributed positive definite matrix and x and sub( b ) denoting b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs distribute where a(ia:ia+n-1,ja:ja+n-1) is an n-by-n matrix and x and b(ib:ib+n-1,jb:jb+nrhs-1) are n-by-nrhs matrices error bounds on the solution and a condition estimate are also the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. the following are restrictions on the input parameters. some of thes may reflect fundamental technical limitations. these are alignment restrictions that may or may not be remove correspond to user specified eigenvalues. pzstein does not orthogonalize vectors that are on different processes. the exten eigenvectors that are to be orthogonalized are computed by the same upper triangular part is not referenced. if diag = 'u', the diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also no the right eigenvector x and the left eigenvector y of t corresponding to an eigenvalue w are defined by t*x = w*x, y'*t = w*y' referenced. if diag = 'u', the diagonal elements of sub( a ) are als of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assume matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer and numroc, indxg2p are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. here q and p**h are the unitary distributed matrices determined b bidiagonal form: a(ia:*,ja:*) = q * b * p**h. q and p**h are defined if side = 'r', 1 <= ilo <= ihi <= max(1,n); ilo and ihi are relative indexes a (local input) complex*16 pointer into the local memory ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. ilcm, indxg2p and numroc are scalapack tool functions the subroutine blacs_gridinfo. rows 1 to kl+ku+1, and the multipliers used during the factorization are stored in rows kl+ku+2 to 2*kl+ku+1 which is about to be factorized. the number of rows in the partitioning are jb, i2, i3 respectively, and the number and the subdiagonal elements of a31 lie outside the band. slamsh sends multiple shifts through a small (single node) matrix to see how consecutive small subdiagonal elements are modified b that can be sent through. slasorte sorts eigenpairs so that real eigenpairs are together an since every 2nd subdiagonal is guaranteed to be zero. if eigenvalues j and j-1 are too close, add a relativel if eigenvectors are desired, then save rotations rows 1 to kl+ku+1, and the multipliers used during the factorization are stored in rows kl+ku+2 to 2*kl+ku+1 which is about to be factorized. the number of rows in the partitioning are jb, i2, i3 respectively, and the number and the subdiagonal elements of a31 lie outside the band. i1 and i2 are the indices of the first row and last column of being computed, i1 and i2 are set inside the main loop. zlamsh sends multiple shifts through a small (single node) matrix to see how consecutive small subdiagonal elements are modified b that can be sent through. on entry, the elements of the input matrix. on exit, they are overwritten by the elements of th = 'l': e is the subdiagonal of l, and a = l*d*l'. (the two forms are equivalent if a is real. trans (input) character if eigenvectors are desired, then save rotations |
| area area local copying in the block bidiagonal area local copying in the block bidiagonal area local copying in the block bidiagonal area local copying in the block bidiagonal area |
| argu argu .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . |
| Argument Argument .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. scalar Arguments . .. array arguments .. .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. .. array Arguments . .. .. array Arguments . bugs .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. scalar Arguments . .. array arguments .. .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. .. array Arguments . .. .. array Arguments . bugs .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . the tuning parameters for their particular machine using the option and problem size information in the Arguments this routine will not function correctly if it is converted to all .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. scalar Arguments . .. array arguments .. .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. .. array Arguments . .. .. array Arguments . bugs .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. scalar Arguments . .. array arguments .. .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. .. array Arguments . .. .. array Arguments . bugs .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . Argument checking that is specific to divide & conquer routin .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . |
| Arguments Arguments Arguments .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Arguments .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. scalar Arguments . .. array arguments .. .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. .. array Arguments . .. .. array Arguments . bugs .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. scalar Arguments . .. array arguments .. .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Arguments .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Arguments .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. .. array Arguments . .. .. array Arguments . bugs .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . the tuning parameters for their particular machine using the option and problem size information in the Arguments this routine will not function correctly if it is converted to all .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. scalar Arguments . .. array arguments .. .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Arguments .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Arguments .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. .. array Arguments . .. .. array Arguments . bugs .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. scalar Arguments . .. array arguments .. .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. .. array Arguments . .. .. array Arguments . bugs .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Arguments .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . Arguments .. .. array Arguments . .. .. array Arguments . .. .. array Arguments . |
| arithmetic arithmetic pcheevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch of the values computed by pdlamch. this subroutine is needed because pdlamch does not compensate for poor arithmetic in the upper half o a flag which indicates whether n(w) should be speeded up by exploiting ieee arithmetic info (output) integer 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. is not on an ieee mchine, set the compile time flag no_ieee to 1 (in slmake.inc). the features of ieee arithmetic tha arithmetic (b) the sign bit of a single precision floating 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. pdsyevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch of the values computed by pslamch. this subroutine is needed because pslamch does not compensate for poor arithmetic in the upper half o a flag which indicates whether n(w) should be speeded up by exploiting ieee arithmetic info (output) integer 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. is not on an ieee mchine, set the compile time flag no_ieee to 1 (in slmake.inc). the features of ieee arithmetic tha arithmetic (b) the sign bit of a double precision floating 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. pssyevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch pzheevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch |
| around around 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 |
| arrange arrange indxc (output) integer array, dimension (n) the permutation used to arrange the columns of the deflate elements only at and above n1, the second contains indxc (output) integer array, dimension (n) the permutation used to arrange the columns of the deflate elements only at and above n1, the second contains |
| array array v1 (local input/local output) complex array o its global index. v1(1) = amax, v1(2) = indx. .. .. array arguments . .. .. local arrays . .. external functions .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external functions .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external functions .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. .. array arguments . .. .. array arguments . bugs .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external functions .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external subroutines .. .. .. local arrays . .. external subroutines .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external functions .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external subroutines .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. .. array arguments . .. .. array arguments . bugs .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external functions .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external subroutines .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. .. array arguments . .. .. array arguments . bugs .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. .. array arguments . .. .. array arguments . bugs .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external functions .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external subroutines .. .. .. local arrays . .. external subroutines .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external functions .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. local arrays . .. external functions .. .. .. array arguments . v1 (local input/local output) complex*16 array o its global index. v1(1) = amax, v1(2) = indx. .. .. array arguments . .. .. local arrays . .. external functions .. .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . .. .. array arguments . |
| Arrays Arrays .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external functions .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine calculates the size for all work Arrays. each of these values is returned in the firs is issued by pxerbla. query is assumed; the routine only calculates the optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the optimal size for all work Arrays. each of these values is returne error message is issued by pxerbla. query is assumed; the routine only calculates the optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. pchettrd uses five local Arrays work ( inh ) dimension ( np, anb+1): array h .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external subroutines .. .. .. local Arrays . .. external subroutines .. .. .. local Arrays . .. external subroutines .. .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. mm (global input) integer the number of columns in the Arrays vl and/or vr. mm >= m m (global output) integer query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external subroutines .. .. .. local Arrays . .. external subroutines .. .. .. local Arrays . .. external subroutines .. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the size required for optimal performance for all work Arrays. each o corresponding work arrays, and no error message is issued by query is assumed; the routine only calculates the size required for optimal performance on all work Arrays corresponding work array, and no error message is issued by query is assumed; the routine only calculates the optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. pdsyttrd uses five local Arrays work ( inh ) dimension ( np, anb+1): array h query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external subroutines .. .. .. local Arrays . .. external subroutines .. .. .. local Arrays . .. external subroutines .. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the size required for optimal performance for all work Arrays. each o corresponding work arrays, and no error message is issued by query is assumed; the routine only calculates the size required for optimal performance on all work Arrays corresponding work array, and no error message is issued by query is assumed; the routine only calculates the optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. pssyttrd uses five local Arrays work ( inh ) dimension ( np, anb+1): array h query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine calculates the size for all work Arrays. each of these values is returned in the firs is issued by pxerbla. query is assumed; the routine only calculates the optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the optimal size for all work Arrays. each of these values is returne error message is issued by pxerbla. query is assumed; the routine only calculates the optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. pzhettrd uses five local Arrays work ( inh ) dimension ( np, anb+1): array h .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external subroutines .. .. .. local Arrays . .. external subroutines .. .. .. local Arrays . .. external subroutines .. .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. version 1.0. they simplify and shorten the descriptor for 1d Arrays since scalapack supports two-dimensional arrays as the fundamental .. .. local Arrays . .. external subroutines .. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. mm (global input) integer the number of columns in the Arrays vl and/or vr. mm >= m m (global output) integer query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. query is assumed; the routine only calculates the minimum and optimal size for all work Arrays. each of thes work array, and no error message is issued by pxerbla. .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external functions .. .. .. local Arrays . .. external functions .. |
| ascending ascending on normal exit, the first m entries contain the selected eigenvalues in ascending order z (local output) complex array, w (global output) real array, dimension (n) if info=0, the eigenvalues in ascending order z (local output) complex array, on normal exit, the first m entries contain the selected eigenvalues in ascending order orfac (global input) real on normal exit, the first m entries contain the selected eigenvalues in ascending order orfac (global input) real on output, the first m elements contain the input eigenvalues in ascending order note : to obtain orthogonal vectors, it is best if the permutation used to sort the contents of dlamda into ascending order indxc (output) integer array, dimension (n) the permutation used to sort the contents of dlamda into ascending order indcol (workspace) integer array, dimension (n) on output, the first m elements contain the input eigenvalues in ascending order note : to obtain orthogonal vectors, it is best if on normal exit, the first m entries contain the selected eigenvalues in ascending order z (local output) double precision array, w (global output) double precision array, dimension (n) if info=0, the eigenvalues in ascending order z (local output) double precision array, on normal exit, the first m entries contain the selected eigenvalues in ascending order orfac (global input) double precision on normal exit, the first m entries contain the selected eigenvalues in ascending order orfac (global input) double precision the permutation used to sort the contents of dlamda into ascending order indxc (output) integer array, dimension (n) the permutation used to sort the contents of dlamda into ascending order indcol (workspace) integer array, dimension (n) on output, the first m elements contain the input eigenvalues in ascending order note : to obtain orthogonal vectors, it is best if on normal exit, the first m entries contain the selected eigenvalues in ascending order z (local output) real array, w (global output) real array, dimension (n) if info=0, the eigenvalues in ascending order z (local output) real array, on normal exit, the first m entries contain the selected eigenvalues in ascending order orfac (global input) real on normal exit, the first m entries contain the selected eigenvalues in ascending order orfac (global input) real on normal exit, the first m entries contain the selected eigenvalues in ascending order z (local output) complex*16 array, w (global output) double precision array, dimension (n) if info=0, the eigenvalues in ascending order z (local output) complex*16 array, on normal exit, the first m entries contain the selected eigenvalues in ascending order orfac (global input) double precision on normal exit, the first m entries contain the selected eigenvalues in ascending order orfac (global input) double precision on output, the first m elements contain the input eigenvalues in ascending order note : to obtain orthogonal vectors, it is best if |
| ask ask pdstebz computes the eigenvalues of a symmetric tridiagonal matrix in parallel. the user may ask for all eigenvalues, all eigenvalues i static partitioning of work is done at the beginning of pdstebz which psstebz computes the eigenvalues of a symmetric tridiagonal matrix in parallel. the user may ask for all eigenvalues, all eigenvalues i static partitioning of work is done at the beginning of psstebz which |
| asso asso each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process |
| associated associated each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process ===== each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process ===== a description vector is associated with each 2d block-cyclicly dis establish the mapping between a matrix entry and its corresponding each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process ===== each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process rho (global input/output) double precision on entry, the off-diagonal element associated with the rank- being recombined. rho (global input/output) double precision on entry, the off-diagonal element associated with the rank- being recombined. each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process ===== a description vector is associated with each 2d block-cyclicly dis establish the mapping between a matrix entry and its corresponding each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process ===== each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process rho (global input/output) real on entry, the off-diagonal element associated with the rank- being recombined. rho (global input/output) real on entry, the off-diagonal element associated with the rank- being recombined. each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process ===== a description vector is associated with each 2d block-cyclicly dis establish the mapping between a matrix entry and its corresponding each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process ===== each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process ===== a description vector is associated with each 2d block-cyclicly dis establish the mapping between a matrix entry and its corresponding each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process each global data object is described by an associated descriptio the mapping between an object element and its corresponding process |
| assume assume the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its or its conjugate-transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension r x c. locr( k ) denote distributed over the r processes of its process column. similarly, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix, and r and t assume one of the forms if n >= m, r = ( r11 ) m , or if n < m, r = ( r11 r12 ) n, where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix, and r and t assume one of the forms if m <= n, r = ( 0 r12 ) m, or if m > n, r = ( r11 ) m-n, in its present form, pcheev assumes a homogeneous system and make different processes. because of this, it is possible that a let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its sub( b )*sub( a )*x=(lambda)*x. here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to b to be hermitian positive definite. let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). the value of sumsq is assumed to be at least unity and the value o interchange is initiated for each of rows or columns k1 trough k2 of sub( a ). this routine assumes that the pivoting information ha also note that this routine will only work for k1-k2 being in the let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension r x c would receive if k were distributed over the r processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension r x c would receive if k were distributed over the r processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by- if nq >= k, q = h(1) h(2) . . . h(k); let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its or its transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension r x c. locr( k ) denote distributed over the r processes of its process column. similarly, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where q is an n-by-n orthogonal matrix, z is a p-by-p orthogonal matrix, and r and t assume one of the forms if n >= m, r = ( r11 ) m , or if n < m, r = ( r11 r12 ) n, where q is an n-by-n orthogonal matrix, z is a p-by-p orthogonal matrix, and r and t assume one of the forms if m <= n, r = ( 0 r12 ) m, or if m > n, r = ( r11 ) m-n, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its it assumes that the input array, bycol, is distributed acros bycol. the output array, byall, will be identical on all processes it assumes that the input array, byrow, is distributed acros byrow. the output array, byall, will be identical on all processes let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ). the value of sumsq is assumed to be non-negative and scl returns th interchange is initiated for each of rows or columns k1 trough k2 of sub( a ). this routine assumes that the pivoting information ha also note that this routine will only work for k1-k2 being in the let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by- if nq >= k, q = h(1) h(2) . . . h(k); let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension r x c would receive if k were distributed over the r processes of its in its present form, pdsyev assumes a homogeneous system and make the different processes. because of this, it is possible that a let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its sub( b )*sub( a )*x=(lambda)*x. here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to b to be symmetric positive definite. let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its or its transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension r x c. locr( k ) denote distributed over the r processes of its process column. similarly, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where q is an n-by-n orthogonal matrix, z is a p-by-p orthogonal matrix, and r and t assume one of the forms if n >= m, r = ( r11 ) m , or if n < m, r = ( r11 r12 ) n, where q is an n-by-n orthogonal matrix, z is a p-by-p orthogonal matrix, and r and t assume one of the forms if m <= n, r = ( 0 r12 ) m, or if m > n, r = ( r11 ) m-n, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its it assumes that the input array, bycol, is distributed acros bycol. the output array, byall, will be identical on all processes it assumes that the input array, byrow, is distributed acros byrow. the output array, byall, will be identical on all processes let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ). the value of sumsq is assumed to be non-negative and scl returns th interchange is initiated for each of rows or columns k1 trough k2 of sub( a ). this routine assumes that the pivoting information ha also note that this routine will only work for k1-k2 being in the let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by- if nq >= k, q = h(1) h(2) . . . h(k); let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension r x c would receive if k were distributed over the r processes of its in its present form, pssyev assumes a homogeneous system and make the different processes. because of this, it is possible that a let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its sub( b )*sub( a )*x=(lambda)*x. here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to b to be symmetric positive definite. let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its or its conjugate-transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension r x c. locr( k ) denote distributed over the r processes of its process column. similarly, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix, and r and t assume one of the forms if n >= m, r = ( r11 ) m , or if n < m, r = ( r11 r12 ) n, where q is an n-by-n unitary matrix, z is a p-by-p unitary matrix, and r and t assume one of the forms if m <= n, r = ( 0 r12 ) m, or if m > n, r = ( r11 ) m-n, in its present form, pzheev assumes a homogeneous system and make different processes. because of this, it is possible that a let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its sub( b )*sub( a )*x=(lambda)*x. here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to b to be hermitian positive definite. let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). the value of sumsq is assumed to be at least unity and the value o interchange is initiated for each of rows or columns k1 trough k2 of sub( a ). this routine assumes that the pivoting information ha also note that this routine will only work for k1-k2 being in the let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension r x c would receive if k were distributed over the r processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension r x c would receive if k were distributed over the r processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by- if nq >= k, q = h(1) h(2) . . . h(k); let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its let k be the number of rows or columns of a distributed matrix, and assume that its process grid has dimension p x q would receive if k were distributed over the p processes of its |
| assumed assumed on entry, the matrix of shifts. only the 2x2 diagonal of s is referenced. it is assumed that s has jblk double shift on exit, the data is rearranged in the best order for on entry, the matrix of shifts. only the 2x2 diagonal of s is referenced. it is assumed that s has jblk double shift on exit, the data is rearranged in the best order for if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+jhi:ja+n-1. see further details. if n > 0, ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+ihi:ja+n-1. see further details. if n > 0, if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding or its conjugate-transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, the lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued if lwork = -1, then lwork is global input and a workspace query is assumed; the routine calculates the size for al entry of the corresponding work array, and no error message if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates th values is returned in the first entry of the corresponding sub( b )*sub( a )*x=(lambda)*x. here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to b to be hermitian positive definite. if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates th values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). the value of sumsq is assumed to be at least unity and the value o if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also not referenced and are assumed to be 1 ia (global input) integer if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by- if nq >= k, q = h(1) h(2) . . . h(k); if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+jhi:ja+n-1. see further details. if n > 0, ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+ihi:ja+n-1. see further details. if n > 0, if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding or its transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding elements of the tridiagonal matrix t. these elements are assumed to be interleaved in memory for better cach d(1),d(3),...,d(2*n-1), while the squares of the off-diagonal elements of the tridiagonal matrix t. these elements are assumed to be interleaved in memory for better cach d(1),d(3),...,d(2*n-1), while the squares of the off-diagonal bycol is distributed across the process rows all process columns are assumed to contain the same valu byall (global output) double precision global dimension( n ) byrow is distributed across the process columns all process rows are assumed to contain the same valu byall (global output) double precision global dimension( n ) where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ). the value of sumsq is assumed to be non-negative and scl returns th if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by- if nq >= k, q = h(1) h(2) . . . h(k); if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding note : it is assumed that the user is on an ieee machine. if the use to 1 (in slmake.inc). the features of ieee arithmetic that if lwork = -1, the lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, the lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued if lwork = -1, the lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued efficiently with no guarantee on orthogonality. if range='v', it is assumed that all eigenvector sub( b )*sub( a )*x=(lambda)*x. here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to b to be symmetric positive definite. if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates th values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also not referenced and are assumed to be 1 ia (global input) integer if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+jhi:ja+n-1. see further details. if n > 0, ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+ihi:ja+n-1. see further details. if n > 0, if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding or its transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding elements of the tridiagonal matrix t. these elements are assumed to be interleaved in memory for better cach d(1),d(3),...,d(2*n-1), while the squares of the off-diagonal elements of the tridiagonal matrix t. these elements are assumed to be interleaved in memory for better cach d(1),d(3),...,d(2*n-1), while the squares of the off-diagonal bycol is distributed across the process rows all process columns are assumed to contain the same valu byall (global output) real global dimension( n ) byrow is distributed across the process columns all process rows are assumed to contain the same valu byall (global output) real global dimension( n ) where x( i ) = sub( x ) = x( ix+(jx-1)*descx(m_)+(i-1)*incx ). the value of sumsq is assumed to be non-negative and scl returns th if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by- if nq >= k, q = h(1) h(2) . . . h(k); if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding note : it is assumed that the user is on an ieee machine. if the use to 1 (in slmake.inc). the features of ieee arithmetic that if lwork = -1, the lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, the lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued if lwork = -1, the lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued efficiently with no guarantee on orthogonality. if range='v', it is assumed that all eigenvector sub( b )*sub( a )*x=(lambda)*x. here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to b to be symmetric positive definite. if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates th values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also not referenced and are assumed to be 1 ia (global input) integer if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+jhi:ja+n-1. see further details. if n > 0, ihi (global input) integer it is assumed that sub( a ) is already upper triangular i and ja+ihi:ja+n-1. see further details. if n > 0, if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding or its conjugate-transpose, using a qr or lq factorization of sub( a ). it is assumed that sub( a ) has full rank the following options are provided: if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, the lwork is global input and a workspace query is assumed; the routine only calculates the minimu as the first element of work and no error message is issued if lwork = -1, then lwork is global input and a workspace query is assumed; the routine calculates the size for al entry of the corresponding work array, and no error message if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates th values is returned in the first entry of the corresponding sub( b )*sub( a )*x=(lambda)*x. here sub( a ) denoting a( ia:ia+n-1, ja:ja+n-1 ) is assumed to b to be hermitian positive definite. if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates th values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding where x( i ) = sub( x ) = abs( x( ix+(jx-1)*descx(m_)+(i-1)*incx ) ). the value of sumsq is assumed to be at least unity and the value o if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding diagonal elements of a(ia:ia+n-1,ja:ja+n-1) are also not referenced and are assumed to be 1 ia (global input) integer if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer of sub( a ) is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed matrix, in the same storage format. is not referenced. if diag = 'u', the diagonal elements of sub( a ) are also not referenced and are assumed to be 1 ia (global input) integer if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if vect = 'q', a(ia:*,ja:*) is assumed to have been an nq-by- if nq >= k, q = h(1) h(2) . . . h(k); if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding if lwork = -1, then lwork is global input and a workspace query is assumed; the routine only calculates the minimu values is returned in the first entry of the corresponding on entry, the matrix of shifts. only the 2x2 diagonal of s is referenced. it is assumed that s has jblk double shift on exit, the data is rearranged in the best order for on entry, the matrix of shifts. only the 2x2 diagonal of s is referenced. it is assumed that s has jblk double shift on exit, the data is rearranged in the best order for |
| assumes assumes the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, in its present form, pcheev assumes a homogeneous system and make different processes. because of this, it is possible that a pcheevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch interchange is initiated for each of rows or columns k1 trough k2 of sub( a ). this routine assumes that the pivoting information ha also note that this routine will only work for k1-k2 being in the the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, it assumes that the input array, bycol, is distributed acros bycol. the output array, byall, will be identical on all processes it assumes that the input array, byrow, is distributed acros byrow. the output array, byall, will be identical on all processes interchange is initiated for each of rows or columns k1 trough k2 of sub( a ). this routine assumes that the pivoting information ha also note that this routine will only work for k1-k2 being in the the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, in its present form, pdsyev assumes a homogeneous system and make the different processes. because of this, it is possible that a in its present form, pdsyevd assumes a homogeneous system and make the different processes. because of this, it is possible that a pdsyevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, it assumes that the input array, bycol, is distributed acros bycol. the output array, byall, will be identical on all processes it assumes that the input array, byrow, is distributed acros byrow. the output array, byall, will be identical on all processes interchange is initiated for each of rows or columns k1 trough k2 of sub( a ). this routine assumes that the pivoting information ha also note that this routine will only work for k1-k2 being in the the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, in its present form, pssyev assumes a homogeneous system and make the different processes. because of this, it is possible that a in its present form, pssyevd assumes a homogeneous system and make the different processes. because of this, it is possible that a pssyevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, in its present form, pzheev assumes a homogeneous system and make different processes. because of this, it is possible that a pzheevx assumes ieee 754 standard compliant arithmetic. to por the appropriate slmake.inc file to include the compiler switch interchange is initiated for each of rows or columns k1 trough k2 of sub( a ). this routine assumes that the pivoting information ha also note that this routine will only work for k1-k2 being in the the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, the divide and conqer algorithm assumes the matrix is narrowl it is best to distribute the input matrix a one-dimensionally, |
| assuming assuming grow as the square of the cluster size, all other factors remaining equal and assuming enough workspace. les execution. grow as the square of the cluster size, all other factors remaining equal and assuming enough workspace. les execution. the node owning h(m,m) does not. this will occur on a border and can happen in no more than 3 locations per block assuming values: a buffer to send diagonally down and right, a buffer the node owning h(m,m) does not. this will occur on a border and can happen in no more than 3 locations per block assuming values: a buffer to send diagonally down and right, a buffer grow as the square of the cluster size, all other factors remaining equal and assuming enough workspace. les execution. grow as the square of the cluster size, all other factors remaining equal and assuming enough workspace. les execution. the node owning h(m,m) does not. this will occur on a border and can happen in no more than 3 locations per block assuming values: a buffer to send diagonally down and right, a buffer grow as the square of the cluster size, all other factors remaining equal and assuming enough workspace. les execution. grow as the square of the cluster size, all other factors remaining equal and assuming enough workspace. les execution. grow as the square of the cluster size, all other factors remaining equal and assuming enough workspace. les execution. grow as the square of the cluster size, all other factors remaining equal and assuming enough workspace. les execution. the node owning h(m,m) does not. this will occur on a border and can happen in no more than 3 locations per block assuming values: a buffer to send diagonally down and right, a buffer |
| assumptions assumptions this code makes very mild assumptions about floating poin add/subtract, or on those binary machines without guard digits this code makes very mild assumptions about floating poin add/subtract, or on those binary machines without guard digits this code makes very mild assumptions about floating poin add/subtract, or on those binary machines without guard digits this code makes very mild assumptions about floating poin add/subtract, or on those binary machines without guard digits |
| ASUM ASUM pdzsum1 returns the sum of absolute values of a complex distributed vector sub( x ) in ASUM where sub( x ) denotes x(ix:ix+n-1,jx:jx), if incx = 1, pscsum1 returns the sum of absolute values of a complex distributed vector sub( x ) in ASUM where sub( x ) denotes x(ix:ix+n-1,jx:jx), if incx = 1, |
| atomic atomic it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, it is best to distribute the input matrix a one-dimensionally, with columns atomic and rows divided amongst the processes p pieces with one stored on each processor, |
| attempted attempted nbulge is the number of bulges that will be attempted nbulge is the number of bulges that will be attempted nbulge is the number of bulges that will be attempted nbulge is the number of bulges that will be attempted |
| attempts attempts if lrwork is too small to guarantee orthogonality, pcheevx attempts to maintain orthogonality i spacing between the eigenvalues. if lrwork is too small to guarantee orthogonality, pchegvx attempts to maintain orthogonality i spacing between the eigenvalues. if lwork is too small to guarantee orthogonality, pdsyevx attempts to maintain orthogonality i spacing between the eigenvalues. if lwork is too small to guarantee orthogonality, pdsygvx attempts to maintain orthogonality i spacing between the eigenvalues. if lwork is too small to guarantee orthogonality, pssyevx attempts to maintain orthogonality i spacing between the eigenvalues. if lwork is too small to guarantee orthogonality, pssygvx attempts to maintain orthogonality i spacing between the eigenvalues. if lrwork is too small to guarantee orthogonality, pzheevx attempts to maintain orthogonality i spacing between the eigenvalues. if lrwork is too small to guarantee orthogonality, pzhegvx attempts to maintain orthogonality i spacing between the eigenvalues. |
| August August current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== current address: lawrence livermore national labs. this version released: August, 2001 ===================================================================== |
| Australian Australian andrew j. cleary, livermore national lab and university of tenn., and marbwus hegland, Australian natonal university. feb., 1997 andrew j. cleary, livermore national lab and university of tenn., and markus hegland, Australian national university. feb., 1997 last modified by: peter arbenz, institute of scientific computing, andrew j. cleary, livermore national lab and university of tenn., and markus hegland, Australian national university. feb., 1997 last modified by: peter arbenz, institute of scientific computing, andrew j. cleary, livermore national lab and university of tenn., and marbwus hegland, Australian natonal university. feb., 1997 |
| auxiliary auxiliary separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) complex array, dimension laf. auxiliary fillin space pcdbtrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) complex array, dimension laf. auxiliary fillin space pcdttrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) complex array, dimension laf. auxiliary fillin space pcgbtrf and this is stored in af. if a linear system this is an auxiliary routine called by pcgebrd notes pclacp3 is an auxiliary routine that copies from a global paralle the entire submatrix that is copied gets placed on one node or this is an auxiliary routine called by pcgehrd. in the followin this is an auxiliary routine called by pchetrd to redistribute d, this is an auxiliary routine called by pchetrd notes separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) complex array, dimension laf. auxiliary fillin space pcpbtrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) complex array, dimension laf. auxiliary fillin space pcpttrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) double precision array, dimension laf. auxiliary fillin space pddbtrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) double precision array, dimension laf. auxiliary fillin space pddttrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) double precision array, dimension laf. auxiliary fillin space pdgbtrf and this is stored in af. if a linear system this is an auxiliary routine called by pdgebrd notes pdlacp3 is an auxiliary routine that copies from a global paralle the entire submatrix that is copied gets placed on one node or this is an auxiliary routine called by pdgehrd. in the followin this is an auxiliary routine called by pdsytrd to redistribute d, this is an auxiliary routine called by pdsytrd notes separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) double precision array, dimension laf. auxiliary fillin space pdpbtrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) double precision array, dimension laf. auxiliary fillin space pdpttrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) real array, dimension laf. auxiliary fillin space psdbtrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) real array, dimension laf. auxiliary fillin space psdttrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) real array, dimension laf. auxiliary fillin space psgbtrf and this is stored in af. if a linear system this is an auxiliary routine called by psgebrd notes pslacp3 is an auxiliary routine that copies from a global paralle the entire submatrix that is copied gets placed on one node or this is an auxiliary routine called by psgehrd. in the followin this is an auxiliary routine called by pssytrd to redistribute d, this is an auxiliary routine called by pssytrd notes separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) real array, dimension laf. auxiliary fillin space pspbtrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) real array, dimension laf. auxiliary fillin space pspttrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) complex*16 array, dimension laf. auxiliary fillin space pzdbtrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) complex*16 array, dimension laf. auxiliary fillin space pzdttrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) complex*16 array, dimension laf. auxiliary fillin space pzgbtrf and this is stored in af. if a linear system this is an auxiliary routine called by pzgebrd notes pzlacp3 is an auxiliary routine that copies from a global paralle the entire submatrix that is copied gets placed on one node or this is an auxiliary routine called by pzgehrd. in the followin this is an auxiliary routine called by pzhetrd to redistribute d, this is an auxiliary routine called by pzhetrd notes separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) complex*16 array, dimension laf. auxiliary fillin space pzpbtrf and this is stored in af. if a linear system separately (to solve various sets of righthand sides using the same coefficient matrix), the auxiliary space af *must not be altered check auxiliary storage siz af (local output) complex*16 array, dimension laf. auxiliary fillin space pzpttrf and this is stored in af. if a linear system |
| available available particularly small ones (i.e. n < 500 * sqrt(p) ), provided that enough workspace is available to use the tailored codes the tailored codes provide performance that is essentially the result are only available in the scope of sub( x ), i.e i only available in this process row of the grid. similarly if sub( x ) when the result of a vector-oriented pblas call is a scalar, it will be made available only within the scope which owns the vector(s then, the processes which receive the answer will be (note that if the result are only available in the scope of sub( x ), i.e i only available in this process row of the grid. similarly if sub( x ) particularly small ones (i.e. n < 500 * sqrt(p) ), provided that enough workspace is available to use the tailored codes the tailored codes provide performance that is essentially 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 this version provides a set of parameters which should give good, but not optimal, performance on many of the currently available the tuning parameters for their particular machine using the option 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 result are only available in the scope of sub( x ), i.e i only available in this process row of the grid. similarly if sub( x ) particularly small ones (i.e. n < 500 * sqrt(p) ), provided that enough workspace is available to use the tailored codes the tailored codes provide performance that is essentially particularly small ones (i.e. n < 500 * sqrt(p) ), provided that enough workspace is available to use the tailored codes the tailored codes provide performance that is essentially the result are only available in the scope of sub( x ), i.e i only available in this process row of the grid. similarly if sub( x ) when the result of a vector-oriented pblas call is a scalar, it will be made available only within the scope which owns the vector(s then, the processes which receive the answer will be (note that if |
| avoid avoid scale x by (1/abs(x(j)))*abs(a(j,j))*bignum to avoid overflow when dividing by a(j,j) d(1),d(3),...,d(2*n-1), while the squares of the off-diagonal entries are d(2),d(4),...,d(2*n-2). to avoid overflow, th than overflow**(1/2) * underflow**(1/4) in absolute value, this implementation of the sturm sequence loop has conditionals in the innermost loop to avoid overflow and determine the sign of implementation of the sturm sequence loop. the n diagonal elements of the tridiagonal matrix t. to avoid overflow, the matrix must be scaled so that its larges in absolute value, and for greatest accuracy, it should not d(1),d(3),...,d(2*n-1), while the squares of the off-diagonal entries are d(2),d(4),...,d(2*n-2). to avoid overflow, th than overflow**(1/2) * underflow**(1/4) in absolute value, this implementation of the sturm sequence loop has conditionals in the innermost loop to avoid overflow and determine the sign of implementation of the sturm sequence loop. the n diagonal elements of the tridiagonal matrix t. to avoid overflow, the matrix must be scaled so that its larges in absolute value, and for greatest accuracy, it should not scale x by (1/abs(x(j)))*abs(a(j,j))*bignum to avoid overflow when dividing by a(j,j) |
| await await [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** [processor npcol - 1 jumped to here to await next stage ****************************** |