PCSTEIN(l)

📦 version 1.5, in ubuntu jammy

✨ PCSTEIN(l) — LAPACK routine (version 1.5) ✨

okay bestie, sit down, hydrate, because we're about to talk about PCSTEIN and she is a lot but also lowkey iconic 💅

🌸 NAME 🌸

PCSTEIN — computes the eigenvectors of a symmetric tridiagonal matrix in parallel, using inverse iteration. no cap.

🎀 SYNOPSIS 🎀

SUBROUTINE PCSTEIN( N, D, E, M, W, IBLOCK, ISPLIT, ORFAC, Z, IZ, JZ,
                    DESCZ, WORK, LWORK, IWORK, LIWORK, IFAIL, ICLUSTR,
                    GAP, INFO )

    INTEGER         INFO, IZ, JZ, LIWORK, LWORK, M, N

    REAL            ORFAC

    INTEGER         DESCZ( * ), IBLOCK( * ), ICLUSTR( * ), IFAIL( * ),
                    ISPLIT( * ), IWORK( * )

    REAL            D( * ), E( * ), GAP( * ), W( * ), WORK( * )

    COMPLEX         Z( * )

like… look at her. all those args. main character energy fr fr 👑

💖 PURPOSE 💖

PCSTEIN computes the eigenvectors of a symmetric tridiagonal matrix in parallel, using inverse iteration. the eigenvectors it finds correspond to user specified eigenvalues — you pick 'em, she finds 'em 🦋

important: PCSTEIN does not orthogonalize vectors that are on different processes. the extent of orthogonalization is controlled by the input parameter LWORK. eigenvectors that are to be orthogonalized are computed by the same process. PCSTEIN decides on the allocation of work among the processes and then calls SSTEIN2 (a modified LAPACK routine) on each individual process. and like… if insufficient workspace is allocated, the expected orthogonalization may not be done. sad but true 😭

Note : If the eigenvectors obtained are not orthogonal, increase LWORK and run the code again. that's it, that's the fix, bestie.

⭐ Notes ⭐

Each global data object is described by an associated description vector. this vector stores the information required to establish the mapping between an object element and its corresponding process and memory location. 🫶

Let A be a generic term for any 2D block cyclicly distributed array. such a global array has an associated description vector DESCA. in the following comments, the character _ should be read as "of the global array".

  • DTYPE_A (global), stored in DESCA( DTYPE_ ) — the descriptor type. in this case, DTYPE_A = 1.
  • CTXT_A (global), stored in DESCA( CTXT_ ) — the BLACS context handle, indicating the BLACS process grid A is distributed over. the context itself is global, but the handle (the integer value) may vary.
  • M_A (global), stored in DESCA( M_ ) — the number of rows in the global array A.
  • N_A (global), stored in DESCA( N_ ) — the number of columns in the global array A.
  • MB_A (global), stored in DESCA( MB_ ) — the blocking factor used to distribute the rows of the array.
  • NB_A (global), stored in DESCA( NB_ ) — the blocking factor used to distribute the columns of the array.
  • RSRC_A (global), stored in DESCA( RSRC_ ) — the process row over which the first row of the array A is distributed.
  • CSRC_A (global), stored in DESCA( CSRC_ ) — the process column over which the first column of the array A is distributed.
  • LLD_A (local), stored in DESCA( LLD_ ) — the leading dimension of the local array. LLD_A >= MAX(1,LOCr(M_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.

LOCr( K ) denotes the number of elements of K that a process would receive if K were distributed over the p processes of its process column.

Similarly, LOCc( K ) denotes the number of elements of K that a process would receive if K were distributed over the q processes of its process row.

The values of LOCr() and LOCc() may be determined via a call to the ScaLAPACK tool function, NUMROC:

LOCr( M ) = NUMROC( M, MB_A, MYROW, RSRC_A, NPROW ),
LOCc( N ) = NUMROC( N, NB_A, MYCOL, CSRC_A, NPCOL ).

An upper bound for these quantities may be computed by:

LOCr( M ) <= ceil( ceil(M/MB_A)/NPROW )*MB_A
LOCc( N ) <= ceil( ceil(N/NB_A)/NPCOL )*NB_A

bestie we are SO not done yet — more parts incoming, don't go anywhere 💜

✨ ARGUMENTS ✨

okay bestie, this is the part where we go through every single argument one by one. no skipping, no summarizing, we're doing the whole thing 💖 and yes, every type, dimension, default, and weird edge case is staying. periodt.

  • P = NPROW * NPCOL — this is literally the total number of processes, bestie. like, that's the whole vibe. 💅
  • N (global input, INTEGER) — the order of the tridiagonal matrix T. N >= 0. that's it, that's the tea. ✨
  • D (global input, REAL array, dimension (N)) — the n diagonal elements of the tridiagonal matrix T. yes, lowercase n energy. 🎀
  • E (global input, REAL array, dimension (N-1)) — the (n-1) off-diagonal elements of the tridiagonal matrix T. the way it's just N-1... iconic. 🦋
  • M (global input, INTEGER) — the total number of eigenvectors to be found. 0 <= M <= N. no cap. 🌸
  • W (global input/global output, REAL array, dim (M)) — on input, the first M elements of W contain all the eigenvalues for which eigenvectors are to be computed. The eigenvalues should be grouped by split-off block and ordered from smallest to largest within the block (the output array W from PSSTEBZ with ORDER='b' is expected here). This array should be replicated on all processes. On output, the first M elements contain the input eigenvalues in ascending order.

Note: To obtain orthogonal vectors, it is best if eigenvalues are computed to highest accuracy (this can be done by setting ABSTOL to the underflow threshold = SLAMCH('U') --- ABSTOL is an input parameter to PSSTEBZ). 💖

  • IBLOCK (global input, INTEGER array, dimension (N)) — the submatrix indices associated with the corresponding eigenvalues in W -- 1 for eigenvalues belonging to the first submatrix from the top, 2 for those belonging to the second submatrix, etc. (the output array IBLOCK from PSSTEBZ is expected here). slay. 👑
  • ISPLIT (global input, INTEGER array, dimension (N)) — the splitting points, at which T breaks up into submatrices. The first submatrix consists of rows/columns 1 to ISPLIT(1), the second of rows/columns ISPLIT(1)+1 through ISPLIT(2), etc., and the NSPLIT-th consists of rows/columns ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N (the output array ISPLIT from PSSTEBZ is expected here). the math is mathing. 🔥
  • ORFAC (global input, REAL) — ORFAC specifies which eigenvectors should be orthogonalized. Eigenvectors that correspond to eigenvalues which are within ORFAC*||T|| of each other are to be orthogonalized. However, if the workspace is insufficient (see LWORK), this tolerance may be decreased until all eigenvectors to be orthogonalized can be stored in one process. No orthogonalization will be done if ORFAC equals zero. A default value of 10^-3 is used if ORFAC is negative. ORFAC should be identical on all processes. bestie, keep it consistent. 💅
  • Z (local output, COMPLEX array, dimension (DESCZ(DLEN_), N/npcol + NB)) — Z contains the computed eigenvectors associated with the specified eigenvalues. Any vector which fails to converge is set to its current iterate after MAXITS iterations (see SSTEIN2). On output, Z is distributed across the P processes in block cyclic format. it's giving distributed realness. 🌈
  • IZ (global input, INTEGER) — Z's global row index, which points to the beginning of the submatrix which is to be operated on. okurrr. 💜
  • JZ (global input, INTEGER) — Z's global column index, which points to the beginning of the submatrix which is to be operated on. twin. 💜
  • DESCZ (global and local input, INTEGER array of dimension DLEN_) — the array descriptor for the distributed matrix Z. iconic descriptor energy. 🎀
  • WORK (local workspace/global output, REAL array, dimension ( LWORK )) — on output, WORK(1) gives a lower bound on the workspace (LWORK) that guarantees the user desired orthogonalization (see ORFAC). Note that this may overestimate the minimum workspace needed. lowkey important. ⭐
  • LWORK (local input, integer) — LWORK controls the extent of orthogonalization which can be done. The number of eigenvectors for which storage is allocated on each process is NVEC = floor(( LWORK- max(5*N,NP00*MQ00) )/N). Eigenvectors corresponding to eigenvalue clusters of size NVEC - ceil(M/P) + 1 are guaranteed to be orthogonal (the orthogonality is similar to that obtained from CSTEIN2). Note: LWORK must be no smaller than: max(5*N,NP00*MQ00) + ceil(M/P)*N, and should have the same input value on all processes. It is the minimum value of LWORK input on different processes that is significant.

If LWORK = -1, then LWORK is global input and a workspace query is assumed; the routine only calculates the minimum and optimal size for all work arrays. Each of these values is returned in the first entry of the corresponding work array, and no error message is issued by PXERBLA. periodt. 💅

  • IWORK (local workspace/global output, INTEGER array, dimension ( 3*N+P+1 )) — on return, IWORK(1) contains the amount of integer workspace required. On return, the IWORK(2) through IWORK(P+2) indicate the eigenvectors computed by each process. Process I computes eigenvectors indexed IWORK(I+2)+1 thru' IWORK(I+3). the indexing is giving. 🦋
  • LIWORK (local input, INTEGER) — size of array IWORK. Must be >= 3*N + P + 1. If LIWORK = -1, then LIWORK is global input and a workspace query is assumed; the routine only calculates the minimum and optimal size for all work arrays. Each of these values is returned in the first entry of the corresponding work array, and no error message is issued by PXERBLA. same energy as LWORK. ✨
  • IFAIL (global output, integer array, dimension (M)) — on normal exit, all elements of IFAIL are zero. If one or more eigenvectors fail to converge after MAXITS iterations (as in CSTEIN), then INFO > 0 is returned. If mod(INFO,M+1)>0, then for I=1 to mod(INFO,M+1), the eigenvector corresponding to the eigenvalue W(IFAIL(I)) failed to converge (W refers to the array of eigenvalues on output). bestie, if this happens, it's not a vibe. 😭
  • ICLUSTR (global output, integer array, dimension (2*P)) — this output array contains indices of eigenvectors corresponding to a cluster of eigenvalues that could not be orthogonalized due to insufficient workspace (see LWORK, ORFAC and INFO). Eigenvectors corresponding to clusters of eigenvalues indexed ICLUSTR(2*I-1) to ICLUSTR(2*I), I = 1 to INFO/(M+1), could not be orthogonalized due to lack of workspace. Hence the eigenvectors corresponding to these clusters may not be orthogonal. ICLUSTR is a zero terminated array --- ( ICLUSTR(2*K).NE.0 .AND. ICLUSTR(2*K+1).EQ.0 ) if and only if K is the number of clusters. the way it's zero terminated... iconic. 💀
  • GAP (global output, REAL array, dimension (P)) — this output array contains the gap between eigenvalues whose eigenvectors could not be orthogonalized. The INFO/M output values in this array correspond to the INFO/(M+1) clusters indicated by the array ICLUSTR. As a result, the dot product between eigenvectors corresponding to the I^th cluster may be as high as ( O(n)*macheps ) / GAP(I). math queen. 👑
  • INFO (global output, INTEGER) — = 0: successful exit. < 0: If the i-th argument is an array and the j-entry had an illegal value, then INFO = -(i*100+j), if the i-th argument is a scalar and had an illegal value, then INFO = -i. < 0 : if INFO = -I, the I-th argument had an illegal value. > 0 : if mod(INFO,M+1) = I, then I eigenvectors failed to converge in MAXITS iterations. Their indices are stored in the array IFAIL. if INFO/(M+1) = I, then eigenvectors corresponding to I clusters of eigenvalues could not be orthogonalized due to insufficient workspace. The indices of the clusters are stored in the array ICLUSTR. so basically, zero is good, negative is bad, positive is also bad but in a different way. 💅

and that's the whole page, bestie 💖 this iconic manual is from LAPACK version 1.5, dated 12 May 1997, and it's literally PCSTEIN(l) 🫶 no cap.

📦 where this page comes from