complex16OTHERsolve(3)

📦

version 3.11.0 · 2 versions

3.11.0 · debian bookworm (latest)
3.10.0 · ubuntu jammy

💖 complex16OTHERsolve(3) 💖

okay bestie, welcome to complex16OTHERsolve(3) — the LAPACK manual for the complex16 OTHER solve routines. This page is long, so it comes in 6 parts. This is part 1, and more parts are coming, so don't go anywhere 💅.

✨ NAME ✨

complex16OTHERsolve — complex16 Other Solve Routines

🎀 SYNOPSIS 🎀

Functions

Here's the whole function lineup, no cap. Every signature is exactly as written:

       subroutine zgglse (M, N, P, A, LDA, B, LDB, C, D, X, WORK, LWORK, INFO)
            ZGGLSE solves overdetermined or underdetermined systems for OTHER
           matrices
       subroutine zhpsv (UPLO, N, NRHS, AP, IPIV, B, LDB, INFO)
            ZHPSV computes the solution to system of linear equations A * X = B
           for OTHER matrices
       subroutine zhpsvx (FACT, UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX,
           RCOND, FERR, BERR, WORK, RWORK, INFO)
            ZHPSVX computes the solution to system of linear equations A * X =
           B for OTHER matrices
       subroutine zpbsv (UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO)
            ZPBSV computes the solution to system of linear equations A * X = B
           for OTHER matrices
       subroutine zpbsvx (FACT, UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, EQUED,
           S, B, LDB, X, LDX, RCOND, FERR, BERR, WORK, RWORK, INFO)
            ZPBSVX computes the solution to system of linear equations A * X =
           B for OTHER matrices
       subroutine zppsv (UPLO, N, NRHS, AP, B, LDB, INFO)
            ZPPSV computes the solution to system of linear equations A * X = B
           for OTHER matrices
       subroutine zppsvx (FACT, UPLO, N, NRHS, AP, AFP, EQUED, S, B, LDB, X,
           LDX, RCOND, FERR, BERR, WORK, RWORK, INFO)
            ZPPSVX computes the solution to system of linear equations A * X =
           B for OTHER matrices
       subroutine zspsv (UPLO, N, NRHS, AP, IPIV, B, LDB, INFO)
            ZSPSV computes the solution to system of linear equations A * X = B
           for OTHER matrices
       subroutine zspsvx (FACT, UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX,
           RCOND, FERR, BERR, WORK, RWORK, INFO)
            ZSPSVX computes the solution to system of linear equations A * X =
           B for OTHER matrices

🌈 Detailed Description 🌈

This is the group of complex16 Other Solve routines. periodt.

🔥 Function Documentation 🔥

💅 `subroutine zgglse` 💅

   subroutine zgglse (integer M, integer N, integer P, complex*16, dimension(
       lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer LDB,
       complex*16, dimension( * ) C, complex*16, dimension( * ) D, complex*16,
       dimension( * ) X, complex*16, dimension( * ) WORK, integer LWORK,
       integer INFO)
        ZGGLSE solves overdetermined or underdetermined systems for OTHER
       matrices

Purpose

ZGGLSE solves the linear equality-constrained least squares (LSE) problem:

        minimize || c - A*x ||_2   subject to   B*x = d

where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and

         rank(B) = P and  rank( (A) ) = N.
                              ( (B) )

These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by

   B = (0 R)*Q,   A = Z*T*Q.

Parameters

M — M is INTEGER. The number of rows of the matrix A. M >= 0.
N — N is INTEGER. The number of columns of the matrices A and B. N >= 0.
P — P is INTEGER. The number of rows of the matrix B. 0 <= P <= N <= M+P.
A — A is COMPLEX*16 array, dimension (LDA,N). On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix T.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — B is COMPLEX*16 array, dimension (LDB,N). On entry, the P-by-N matrix B. On exit, the upper triangle of the subarray B(1:P,N-P+1:N) contains the P-by-P upper triangular matrix R.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,P).
C — C is COMPLEX*16 array, dimension (M). On entry, C contains the right hand side vector for the least squares part of the LSE problem. On exit, the residual sum of squares for the solution is given by the sum of squares of elements N-P+1 to M of vector C.
D — D is COMPLEX*16 array, dimension (P). On entry, D contains the right hand side vector for the constrained equation. On exit, D is destroyed.
X — X is COMPLEX*16 array, dimension (N). On exit, X is the solution of the LSE problem.
WORK — WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK — LWORK is INTEGER. The dimension of the array WORK. LWORK >= max(1,M+N+P). For optimum performance LWORK >= P+min(M,N)+max(M,N)*NB, where NB is an upper bound for the optimal blocksizes for ZGEQRF, CGERQF, ZUNMQR and CUNMRQ. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.
INFO — INFO is INTEGER
- = 0: successful exit.
- < 0: if INFO = -i, the i-th argument had an illegal value.
- = 1: the upper triangular factor R associated with B in the generalized RQ factorization of the pair (B, A) is singular, so that rank(B) < P; the least squares solution could not be computed.
- = 2: the (N-P) by (N-P) part of the upper trapezoidal factor T associated with A in the generalized RQ factorization of the pair (B, A) is singular, so that

rank( (A) ) < N; the least squares solution could not
    ( (B) )
be computed.

Author

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

💖 `subroutine zhpsv` 💖

   subroutine zhpsv (character UPLO, integer N, integer NRHS, complex*16,
       dimension( * ) AP, integer, dimension( * ) IPIV, complex*16, dimension(
       ldb, * ) B, integer LDB, integer INFO)
        ZHPSV computes the solution to system of linear equations A * X = B for
       OTHER matrices

Purpose

ZHPSV computes the solution to a complex system of linear equations

   A * X = B,

where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices.

The diagonal pivoting method is used to factor A as

   A = U * D * U**H,  if UPLO = 'U', or
   A = L * D * L**H,  if UPLO = 'L',

where U (or L) is a product of permutation and unit upper (lower) triangular matrices, D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.

Parameters

UPLO — UPLO is CHARACTER*1
- = 'U': Upper triangle of A is stored;
- = 'L': Lower triangle of A is stored.
N — N is INTEGER. The number of linear equations, i.e., the order of the matrix A. N >= 0.
NRHS — NRHS is INTEGER. The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
AP — AP is COMPLEX*16 array, dimension (N*(N+1)/2). On entry, the upper or lower triangle of the Hermitian matrix A, packed columnwise in a linear array. The j-th column of A is stored in the array AP as follows:
- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
- if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n. See below for further details.

On exit, the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**H or A = L*D*L**H as computed by ZHPTRF, stored as a packed triangular matrix in the same storage format as A.

IPIV — IPIV is INTEGER array, dimension (N). Details of the interchanges and the block structure of D, as determined by ZHPTRF. If IPIV(k) > 0, then rows and columns k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1 diagonal block. If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k) is a 2-by-2 diagonal block. If UPLO = 'L' and IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
B — B is COMPLEX*16 array, dimension (LDB,NRHS). On entry, the N-by-NRHS right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
INFO — INFO is INTEGER
- = 0: successful exit
- < 0: if INFO = -i, the i-th argument had an illegal value
- > 0: if INFO = i, D(i,i) is exactly zero. The factorization has been completed, but the block diagonal matrix D is exactly singular, so the solution could not be computed.

Author

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Further Details:

The packed storage scheme is illustrated by the following example when N = 4, UPLO = 'U':

Two-dimensional storage of the Hermitian matrix A:

   a11 a12 a13 a14
       a22 a23 a24
           a33 a34     (aij = conjg(aji))
               a44

Packed storage of the upper triangle of A:

AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ]

and bestie, that's just part 1 — there's more where that came from, so stay tuned 💖✨

`zhpsvx` 💖

bestie, okay so ZHPSVX is the main character for solving A * X = B when your matrix is OTHER-coded. The one-liner is: ZHPSVX computes the solution to system of linear equations A * X = B for OTHER matrices.

   subroutine zhpsvx (character FACT, character UPLO, integer N, integer NRHS,
       complex*16, dimension( * ) AP, complex*16, dimension( * ) AFP, integer,
       dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer LDB,
       complex*16, dimension( ldx, * ) X, integer LDX, double precision RCOND,
       double precision, dimension( * ) FERR, double precision, dimension( * )
       BERR, complex*16, dimension( * ) WORK, double precision, dimension( * )
       RWORK, integer INFO)

Purpose ✨

Okay so ZHPSVX uses the diagonal pivoting factorization A = U*D*U**H or A = L*D*L**H to compute the solution to a complex system of linear equations A * X = B, where A is an N-by-N Hermitian matrix stored in packed format and X and B are N-by-NRHS matrices.

Error bounds on the solution and a condition estimate are also provided. 🫶

Description 🧚

The following steps are performed, no cap:

If FACT = 'N', the diagonal pivoting method is used to factor A as

A = U * D * U**H,  if UPLO = 'U', or
A = L * D * L**H,  if UPLO = 'L',

where U (or L) is a product of permutation and unit upper (lower) triangular matrices and D is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. 💅

If some D(i,i)=0, so that D is exactly singular, then the routine returns with INFO = i. Otherwise, the factored form of A is used to estimate the condition number of the matrix A. If the reciprocal of the condition number is less than machine precision, INFO = N+1 is returned as a warning, but the routine still goes on to solve for X and compute error bounds as described below. 😭
The system of equations is solved for X using the factored form of A. ✨
Iterative refinement is applied to improve the computed solution matrix and calculate error bounds and backward error estimates for it. 🔥

Parameters 🎀

FACT — FACT is CHARACTER*1. Specifies whether or not the factored form of A has been supplied on entry.
- = 'F': On entry, AFP and IPIV contain the factored form of A. AFP and IPIV will not be modified.
- = 'N': The matrix A will be copied to AFP and factored.
UPLO — UPLO is CHARACTER*1.
- = 'U': Upper triangle of A is stored;
- = 'L': Lower triangle of A is stored.
N — N is INTEGER. The number of linear equations, i.e., the order of the matrix A. N >= 0.
NRHS — NRHS is INTEGER. The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0.
AP — AP is COMPLEX*16 array, dimension (N*(N+1)/2). The upper or lower triangle of the Hermitian matrix A, packed columnwise in a linear array. The j-th column of A is stored in the array AP as follows:
- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
- if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n. See below for further details. 👀
AFP — AFP is COMPLEX*16 array, dimension (N*(N+1)/2).
- If FACT = 'F', then AFP is an input argument and on entry contains the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**H or A = L*D*L**H as computed by ZHPTRF, stored as a packed triangular matrix in the same storage format as A.
- If FACT = 'N', then AFP is an output argument and on exit contains the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**H or A = L*D*L**H as computed by ZHPTRF, stored as a packed triangular matrix in the same storage format as A.
IPIV — IPIV is INTEGER array, dimension (N).
- If FACT = 'F', then IPIV is an input argument and on entry contains details of the interchanges and the block structure of D, as determined by ZHPTRF.
  - If IPIV(k) > 0, then rows and columns k and IPIV(k) were interchanged and D(k,k) is a 1-by-1 diagonal block.
  - If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
  - If UPLO = 'L' and IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
- If FACT = 'N', then IPIV is an output argument and on exit contains details of the interchanges and the block structure of D, as determined by ZHPTRF.
B — B is COMPLEX*16 array, dimension (LDB,NRHS). The N-by-NRHS right hand side matrix B.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
X — X is COMPLEX*16 array, dimension (LDX,NRHS). If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,N).
RCOND — RCOND is DOUBLE PRECISION. The estimate of the reciprocal condition number of the matrix A. If RCOND is less than the machine precision (in particular, if RCOND = 0), the matrix is singular to working precision. This condition is indicated by a return code of INFO > 0.
FERR — FERR is DOUBLE PRECISION array, dimension (NRHS). The estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). The estimate is as reliable as the estimate for RCOND, and is almost always a slight overestimate of the true error.
BERR — BERR is DOUBLE PRECISION array, dimension (NRHS). The componentwise relative backward error of each solution vector X(j) (i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution).
WORK — WORK is COMPLEX*16 array, dimension (2*N).
RWORK — RWORK is DOUBLE PRECISION array, dimension (N).
INFO — INFO is INTEGER.
- = 0: successful exit
- < 0: if INFO = -i, the i-th argument had an illegal value
- > 0: if INFO = i, and i is
  - <= N: D(i,i) is exactly zero. The factorization has been completed but the factor D is exactly singular, so the solution and error bounds could not be computed. RCOND = 0 is returned.
  - = N+1: D is nonsingular, but RCOND is less than machine precision, meaning that the matrix is singular to working precision. Nevertheless, the solution and error bounds are computed because there are a number of situations where the computed solution can be more accurate than the value of RCOND would suggest.

Author 👑

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Further Details 💅

The packed storage scheme is illustrated by the following example when N = 4, UPLO = 'U':

Two-dimensional storage of the Hermitian matrix A:

   a11 a12 a13 a14
       a22 a23 a24
           a33 a34     (aij = conjg(aji))
               a44

Packed storage of the upper triangle of A:

AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ]

`zpbsv` 🌈

   subroutine zpbsv (character UPLO, integer N, integer KD, integer NRHS,
       complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16,
       dimension( ldb, * ) B, integer LDB, integer INFO)

ZPBSV computes the solution to system of linear equations A * X = B for OTHER matrices.

Purpose ✨

ZPBSV computes the solution to a complex system of linear equations

   A * X = B,

where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices. 🦋

The Cholesky decomposition is used to factor A as

   A = U**H * U,  if UPLO = 'U', or
   A = L * L**H,  if UPLO = 'L',

where U is an upper triangular band matrix, and L is a lower triangular band matrix, with the same number of superdiagonals or subdiagonals as A. The factored form of A is then used to solve the system of equations A * X = B. 💖

Parameters 🍓

UPLO — UPLO is CHARACTER*1.
- = 'U': Upper triangle of A is stored;
- = 'L': Lower triangle of A is stored.
N — N is INTEGER. The number of linear equations, i.e., the order of the matrix A. N >= 0.
KD — KD is INTEGER. The number of superdiagonals of the matrix A if UPLO = 'U', or the number of subdiagonals if UPLO = 'L'. KD >= 0.
NRHS — NRHS is INTEGER. The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
AB — AB is COMPLEX*16 array, dimension (LDAB,N). On entry, the upper or lower triangle of the Hermitian band matrix A, stored in the first KD+1 rows of the array. The j-th column of A is stored in the j-th column of the array AB as follows:
- if UPLO = 'U', AB(KD+1+i-j,j) = A(i,j) for max(1,j-KD)<=i<=j;
- if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(N,j+KD). See below for further details.

On exit, if INFO = 0, the triangular factor U or L from the Cholesky factorization A = U**H *U or A = L*L**H of the band matrix A, in the same storage format as A. 💅

LDAB — LDAB is INTEGER. The leading dimension of the array AB. LDAB >= KD+1. ✨
B — B is COMPLEX*16 array, dimension (LDB,NRHS). On entry, the N-by-NRHS right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X. 🎀
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N). 🌸
INFO — INFO is INTEGER.
- = 0: successful exit 🥳
- < 0: if INFO = -i, the i-th argument had an illegal value 😭
- > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed. 💀

bestie if you see INFO > 0 it's giving singular vibes, no cap.

✨ Author ✨

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

🌈 Further Details 🌈

The band storage scheme is illustrated by the following example, when N = 6, KD = 2, and UPLO = 'U':

             On entry:                       On exit:

                 *    *   a13  a24  a35  a46      *    *   u13  u24  u35  u46
                 *   a12  a23  a34  a45  a56      *   u12  u23  u34  u45  u56
                a11  a22  a33  a44  a55  a66     u11  u22  u33  u44  u55  u66

Similarly, if UPLO = 'L' the format of A is as follows:

             On entry:                       On exit:

                a11  a22  a33  a44  a55  a66     l11  l22  l33  l44  l55  l66
                a21  a32  a43  a54  a65   *      l21  l32  l43  l54  l65   *
                a31  a42  a53  a64   *    *      l31  l42  l53  l64   *    *

Array elements marked * are not used by the routine.

`subroutine zpbsvx` 🦋

   subroutine zpbsvx (character FACT, character UPLO, integer N, integer KD,
       integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB,
       complex*16, dimension( ldafb, * ) AFB, integer LDAFB, character EQUED,
       double precision, dimension( * ) S, complex*16, dimension( ldb, * ) B,
       integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, double
       precision RCOND, double precision, dimension( * ) FERR, double
       precision, dimension( * ) BERR, complex*16, dimension( * ) WORK, double
       precision, dimension( * ) RWORK, integer INFO)

ZPBSVX computes the solution to system of linear equations A * X = B for OTHER matrices. 💖

Purpose:

ZPBSVX uses the Cholesky factorization A = U**H*U or A = L*L**H to compute the solution to a complex system of linear equations

   A * X = B,

where A is an N-by-N Hermitian positive definite band matrix and X and B are N-by-NRHS matrices.

Error bounds on the solution and a condition estimate are also provided. ✨

Description:

The following steps are performed:

If FACT = 'E', real scaling factors are computed to equilibrate the system:

diag(S) * A * diag(S) * inv(diag(S)) * X = diag(S) * B

Whether or not the system will be equilibrated depends on the scaling of the matrix A, but if equilibration is used, A is overwritten by diag(S)*A*diag(S) and B by diag(S)*B.

If FACT = 'N' or 'E', the Cholesky decomposition is used to factor the matrix A (after equilibration if FACT = 'E') as

A = U**H * U,  if UPLO = 'U', or
A = L * L**H,  if UPLO = 'L',

where U is an upper triangular band matrix, and L is a lower triangular band matrix.

If the leading i-by-i principal minor is not positive definite, then the routine returns with INFO = i. Otherwise, the factored form of A is used to estimate the condition number of the matrix A. If the reciprocal of the condition number is less than machine precision, INFO = N+1 is returned as a warning, but the routine still goes on to solve for X and compute error bounds as described below. 😭
The system of equations is solved for X using the factored form of A.
Iterative refinement is applied to improve the computed solution matrix and calculate error bounds and backward error estimates for it. 💅
If equilibration was used, the matrix X is premultiplied by diag(S) so that it solves the original system before equilibration.

Parameters

FACT — FACT is CHARACTER*1. Specifies whether or not the factored form of the matrix A is supplied on entry, and if not, whether the matrix A should be equilibrated before it is factored.
- = 'F': On entry, AFB contains the factored form of A. If EQUED = 'Y', the matrix A has been equilibrated with scaling factors given by S. AB and AFB will not be modified.
- = 'N': The matrix A will be copied to AFB and factored.
- = 'E': The matrix A will be equilibrated if necessary, then copied to AFB and factored.
UPLO — UPLO is CHARACTER*1.
- = 'U': Upper triangle of A is stored;
- = 'L': Lower triangle of A is stored.
N — N is INTEGER. The number of linear equations, i.e., the order of the matrix A. N >= 0.
KD — KD is INTEGER. The number of superdiagonals of the matrix A if UPLO = 'U', or the number of subdiagonals if UPLO = 'L'. KD >= 0.
NRHS — NRHS is INTEGER. The number of right-hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0.
AB — AB is COMPLEX*16 array, dimension (LDAB,N). On entry, the upper or lower triangle of the Hermitian band matrix A, stored in the first KD+1 rows of the array, except if FACT = 'F' and EQUED = 'Y', then A must contain the equilibrated matrix diag(S)*A*diag(S). The j-th column of A is stored in the j-th column of the array AB as follows: if UPLO = 'U', AB(KD+1+i-j,j) = A(i,j) for max(1,j-KD)<=i<=j; if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(N,j+KD). See below for further details. On exit, if FACT = 'E' and EQUED = 'Y', A is overwritten by diag(S)*A*diag(S).
LDAB — LDAB is INTEGER. The leading dimension of the array A. LDAB >= KD+1.
AFB — AFB is COMPLEX*16 array, dimension (LDAFB,N). If FACT = 'F', then AFB is an input argument and on entry contains the triangular factor U or L from the Cholesky factorization A = U**H *U or A = L*L**H of the band matrix A, in the same storage format as A (see AB). If EQUED = 'Y', then AFB is the factored form of the equilibrated matrix A. If FACT = 'N', then AFB is an output argument and on exit returns the triangular factor U or L from the Cholesky factorization A = U**H *U or A = L*L**H. If FACT = 'E', then AFB is an output argument and on exit returns the triangular factor U or L from the Cholesky factorization A = U**H *U or A = L*L**H of the equilibrated matrix A (see the description of A for the form of the equilibrated matrix).
LDAFB — LDAFB is INTEGER. The leading dimension of the array AFB. LDAFB >= KD+1.
EQUED — EQUED is CHARACTER*1. Specifies the form of equilibration that was done.
- = 'N': No equilibration (always true if FACT = 'N').
- = 'Y': Equilibration was done, i.e., A has been replaced by diag(S) * A * diag(S). EQUED is an input argument if FACT = 'F'; otherwise, it is an output argument.
S — S is DOUBLE PRECISION array, dimension (N). The scale factors for A; not accessed if EQUED = 'N'. S is an input argument if FACT = 'F'; otherwise, S is an output argument. If FACT = 'F' and EQUED = 'Y', each element of S must be positive.
B — B is COMPLEX*16 array, dimension (LDB,NRHS). On entry, the N-by-NRHS right hand side matrix B. On exit, if EQUED = 'N', B is not modified; if EQUED = 'Y', B is overwritten by diag(S) * B.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
X — X is COMPLEX*16 array, dimension (LDX,NRHS). If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X to the original system of equations. Note that if EQUED = 'Y', A and B are modified on exit, and the solution to the equilibrated system is inv(diag(S))*X.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,N).
RCOND — RCOND is DOUBLE PRECISION. The estimate of the reciprocal condition number of the matrix A after equilibration (if done). If RCOND is less than the machine precision (in particular, if RCOND = 0), the matrix is singular to working precision. This condition is indicated by a return code of INFO > 0.
FERR — FERR is DOUBLE PRECISION array, dimension (NRHS). The estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). The estimate is as reliable as the estimate for RCOND, and is almost always a slight overestimate of the true error.
BERR — BERR is DOUBLE PRECISION array, dimension (NRHS). The componentwise relative backward error of each solution vector X(j) (i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution).
WORK —
WORK — bestie, WORK is a COMPLEX*16 array, dimension (2*N). It's giving workspace energy. 💖
RWORK — RWORK is a DOUBLE PRECISION array, dimension (N). Real ones only, no cap. ✨
INFO — INFO is an INTEGER, and okay listen:
- = 0: successful exit, we ate. 👑
- < 0: if INFO = -i, the i-th argument had an illegal value. Not iconic. 💀
- > 0: if INFO = i, and i is
  - <= N: the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed. RCOND = 0 is returned. 🚫
  - = N+1: U is nonsingular, but RCOND is less than machine precision, meaning that the matrix is singular to working precision. Nevertheless, the solution and error bounds are computed because there are a number of situations where the computed solution can be more accurate than the value of RCOND would suggest. 🫠

👑 Author 👑

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

🔍 Further Details:

The band storage scheme is illustrated by the following example, when N = 6, KD = 2, and UPLO = 'U':

Two-dimensional storage of the Hermitian matrix A:

   a11  a12  a13
        a22  a23  a24
             a33  a34  a35
                  a44  a45  a46
                       a55  a56
   (aij=conjg(aji))         a66

Band storage of the upper triangle of A:

    *    *   a13  a24  a35  a46
    *   a12  a23  a34  a45  a56
   a11  a22  a33  a44  a55  a66

Similarly, if UPLO = 'L' the format of A is as follows:

   a11  a22  a33  a44  a55  a66
   a21  a32  a43  a54  a65   *
   a31  a42  a53  a64   *    *

Array elements marked * are not used by the routine. Periodt. 💅

🧮 `subroutine zppsv` 🧮

subroutine zppsv (character UPLO, integer N, integer NRHS, complex*16,
    dimension( * ) AP, complex*16, dimension( ldb, * ) B, integer LDB,
    integer INFO)

ZPPSV computes the solution to system of linear equations A * X = B for OTHER matrices. Slay. ✨

🎯 Purpose:

ZPPSV computes the solution to a complex system of linear equations

   A * X = B,

where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices.

The Cholesky decomposition is used to factor A as

   A = U**H * U,  if UPLO = 'U', or
   A = L * L**H,  if UPLO = 'L',

where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

📋 Parameters

UPLO — UPLO is CHARACTER*1. It's giving triangle choice:
- = 'U': Upper triangle of A is stored;
- = 'L': Lower triangle of A is stored.
N — N is INTEGER. The number of linear equations, i.e., the order of the matrix A. N >= 0. No negatives, bestie.
NRHS — NRHS is INTEGER. The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
AP — AP is COMPLEX*16 array, dimension (N*(N+1)/2). On entry, the upper or lower triangle of the Hermitian matrix A, packed columnwise in a linear array. The j-th column of A is stored in the array AP as follows:
- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
- if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n. See below for further details.

On exit, if INFO = 0, the factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H, in the same storage format as A.

B — B is COMPLEX*16 array, dimension (LDB,NRHS). On entry, the N-by-NRHS right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X. Glow up. ✨
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
INFO — INFO is INTEGER.
- = 0: successful exit. 👑
- < 0: if INFO = -i, the i-th argument had an illegal value.
- > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed. 💀

👑 Author 👑

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

🔍 Further Details:

The packed storage scheme is illustrated by the following example when N = 4, UPLO = 'U':

Two-dimensional storage of the Hermitian matrix A:

   a11 a12 a13 a14
       a22 a23 a24
           a33 a34     (aij = conjg(aji))
               a44

Packed storage of the upper triangle of A:

AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ]

🧮 `subroutine zppsvx` 🧮

subroutine zppsvx (character FACT, character UPLO, integer N, integer NRHS,
    complex*16, dimension( * ) AP, complex*16, dimension( * ) AFP, character
    EQUED, double precision, dimension( * ) S, complex*16, dimension( ldb, *
    ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, double
    precision RCOND, double precision, dimension( * ) FERR, double
    precision, dimension( * ) BERR, complex*16, dimension( * ) WORK, double
    precision, dimension( * ) RWORK, integer INFO)

ZPPSVX computes the solution to system of linear equations A * X = B for OTHER matrices. Main character energy. 💅

🎯 Purpose:

ZPPSVX uses the Cholesky factorization A = U**H * U or A = L * L**H to compute the solution to a complex system of linear equations

   A * X = B,

where A is an N-by-N Hermitian positive definite matrix stored in packed format and X and B are N-by-NRHS matrices.

Error bounds on the solution and a condition estimate are also provided. We love an overachiever. ✨

📝 Description:

The following steps are performed:

If FACT = 'E', real scaling factors are computed to equilibrate the system:

   diag(S) * A * diag(S) * inv(diag(S)) * X = diag(S) * B

Whether or not the system will be equilibrated depends on the scaling of the matrix A, but if equilibration is used, A is overwritten by diag(S)*A*diag(S) and B by diag(S)*B.

If FACT = 'N' or 'E', the Cholesky decomposition is used to factor the matrix A (after equilibration if FACT = 'E') as

   A = U**H * U ,  if UPLO = 'U', or
   A = L * L**H,  if UPLO = 'L',

where U is an upper triangular matrix, L is a lower triangular matrix, and **H indicates conjugate transpose.

If the leading i-by-i principal minor is not positive definite, then the routine returns with INFO = i. Otherwise, the factored form of A is used to estimate the condition number of the matrix A. If the reciprocal of the condition number is less than machine precision, INFO = N+1 is returned as a warning, but the routine still goes on to solve for X and compute error bounds as described below.
The system of equations is solved for X using the factored form of A.
Iterative refinement is applied to improve the computed solution matrix and calculate error bounds and backward error estimates for it.
If equilibration was used, the matrix X is premultiplied by diag(S) so that it solves the original system before equilibration.

📋 Parameters

FACT — FACT is CHARACTER*1. Specifies whether or not the factored form of the matrix A is supplied on entry, and if not, whether the matrix A should be equilibrated before it is factored.
- = 'F': On entry, AFP contains the factored form of A. If EQUED = 'Y', the matrix A has been equilibrated with scaling factors given by S. AP and AFP will not be modified.
- = 'N': The matrix A will be copied to AFP and factored.
- = 'E': The matrix A will be equilibrated if necessary, then copied to AFP and factored.
UPLO — UPLO is CHARACTER*1.
- = 'U': Upper triangle of A is stored;
- = 'L': Lower triangle of A is stored.
N — N is INTEGER. The number of linear equations, i.e., the order of the matrix A. N >= 0.
NRHS — NRHS is INTEGER. The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0.
AP — AP is COMPLEX*16 array, dimension (N*(N+1)/2). On entry, the upper or lower triangle of the Hermitian matrix A, packed columnwise in a linear array, except if FACT = 'F' and EQUED = 'Y', then A must contain the equilibrated matrix diag(S)*A*diag(S). The j-th column of A is stored in the array AP as follows:
- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
- if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n. See below for further details. A is not modified if FACT = 'F' or 'N', or if FACT = 'E' and EQUED = 'N' on exit.

On exit, if FACT = 'E' and EQUED = 'Y', A is overwritten by diag(S)*A*diag(S).

AFP — AFP is COMPLEX*16 array, dimension (N*(N+1)/2). If FACT = 'F', then AFP is an input argument and on entry contains the triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H, in the same storage format as A. If EQUED .ne. 'N', then AFP is the factored form of the equilibrated matrix A.

If FACT = 'N', then AFP is an output argument and on exit returns the triangular factor U or L from the Cholesky factorization A = U**H * U or A = L * L**H of the original matrix A.

If FACT = 'E', then AFP is an output argument and on exit it hands you back the triangular factor U or L from the Cholesky factorization A = U**H * U or A = L * L**H of the equilibrated matrix A (peep the description of AP for what the equilibrated matrix looks like 💅).

EQUED

EQUED is CHARACTER*1. It tells you which flavor of equilibration happened:

= 'N': No equilibration (this is always true if FACT = 'N').
= 'Y': Equilibration was done, i.e., A has been replaced by diag(S) * A * diag(S).

EQUED is an input argument if FACT = 'F'; otherwise it's an output argument. no cap 🫶

S

S is DOUBLE PRECISION array, dimension (N).

These are the scale factors for A; not accessed if EQUED = 'N'. S is an input argument if FACT = 'F'; otherwise, S is an output argument. And if FACT = 'F' and EQUED = 'Y', every single element of S must be positive — fr fr, no zeroes, no negatives ✨

B

B is COMPLEX*16 array, dimension (LDB,NRHS).

On entry, it's the N-by-NRHS right hand side matrix B. On exit, if EQUED = 'N', B is not modified; if EQUED = 'Y', B gets overwritten by diag(S) * B. she's getting a glow-up bestie 💅

LDB

LDB is INTEGER.

The leading dimension of the array B. Requirement: LDB >= max(1,N). that's the vibe check 🌸

X

X is COMPLEX*16 array, dimension (LDX,NRHS).

If INFO = 0 or INFO = N+1, this is the N-by-NRHS solution matrix X to the original system of equations. Big heads up though: if EQUED = 'Y', then A and B are modified on exit, and the solution to the equilibrated system is inv(diag(S))*X. it's giving "read the fine print" energy 😭

LDX

LDX is INTEGER.

The leading dimension of the array X. Requirement: LDX >= max(1,N). 💖

RCOND

RCOND is DOUBLE PRECISION.

It's the estimate of the reciprocal condition number of the matrix A after equilibration (if equilibration was done). If RCOND is less than machine precision (and especially if RCOND = 0), the matrix is singular to working precision — that situation gets flagged by a return code of INFO > 0. 💀

FERR

FERR is DOUBLE PRECISION array, dimension (NRHS).

The estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), then FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). This estimate is as reliable as the estimate for RCOND, and it's almost always a slight overestimate of the true error. lowkey humble of it 🎀

BERR

BERR is DOUBLE PRECISION array, dimension (NRHS).

The componentwise relative backward error of each solution vector X(j) — i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution. iconic behavior ✨

WORK

WORK is COMPLEX*16 array, dimension (2*N).

RWORK

RWORK is DOUBLE PRECISION array, dimension (N).

INFO

INFO is INTEGER:

= 0: successful exit 🎉
< 0: if INFO = -i, the i-th argument had an illegal value
> 0: if INFO = i, and i is
- <= N: the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed. RCOND = 0 is returned. 💀
- = N+1: U is nonsingular, but RCOND is less than machine precision, meaning that the matrix is singular to working precision. Nevertheless, the solution and error bounds are computed because there are a number of situations where the computed solution can be more accurate than the value of RCOND would suggest. main character energy honestly 👑

Author

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Further Details

The packed storage scheme is illustrated by the following example when N = 4, UPLO = 'U':

Two-dimensional storage of the Hermitian matrix A:

   a11 a12 a13 a14
       a22 a23 a24
           a33 a34     (aij = conjg(aji))
               a44

Packed storage of the upper triangle of A:

AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ]

subroutine `zspsv` (character UPLO, integer N, integer NRHS, complex16, dimension( ) AP, integer, dimension( * ) IPIV, complex16, dimension( ldb, ) B, integer LDB, integer INFO)

subroutine zspsv (character UPLO, integer N, integer NRHS, complex*16,
    dimension( * ) AP, integer, dimension( * ) IPIV, complex*16, dimension(
    ldb, * ) B, integer LDB, integer INFO)

ZSPSV computes the solution to system of linear equations A * X = B for OTHER matrices. yes bestie, OTHER. we contain multitudes 💜

Purpose

ZSPSV computes the solution to a complex system of linear equations
   A * X = B,
where A is an N-by-N symmetric matrix stored in packed format and X
and B are N-by-NRHS matrices.

The diagonal pivoting method is used to factor A as
   A = U * D * U**T,  if UPLO = 'U', or
   A = L * D * L**T,  if UPLO = 'L',
where U (or L) is a product of permutation and unit upper (lower)
triangular matrices, D is symmetric and block diagonal with 1-by-1
and 2-by-2 diagonal blocks.  The factored form of A is then used to
solve the system of equations A * X = B.

Parameters

UPLO

UPLO is CHARACTER*1:

= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored.

N

N is INTEGER.

The number of linear equations, i.e., the order of the matrix A. N >= 0. 🦋

NRHS

NRHS is INTEGER.

The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. 🌈

AP

AP is COMPLEX*16 array, dimension (N*(N+1)/2).

On entry, the upper or lower triangle of the symmetric matrix A, packed columnwise in a linear array. The j-th column of A is stored in the array AP as follows:

if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

See below for further details 👀

On exit, the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**T or A = L*D*L**T as computed by ZSPTRF, stored as a packed triangular matrix in the same storage format as A. slay ✨

IPIV

IPIV is INTEGER array, dimension (N).

Details of the interchanges and the block structure of D, as determined by ZSPTRF. Here's the tea:

If IPIV(k) > 0, then rows and columns k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1 diagonal block.
If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
If UPLO = 'L' and IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block.

B

B is COMPLEX*16 array, dimension (LDB,NRHS).

On entry, the N-by-NRHS right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X. 💅

LDB

LDB is INTEGER.

The leading dimension of the array B. LDB >= max(1,N). periodt 💖

INFO

INFO is INTEGER:

= 0: successful exit 🎀
< 0: if INFO = -i, the i-th argument had an illegal value
> 0: if INFO = i, D(i,i) is exactly zero. The factorization has been completed, but the block diagonal matrix D is exactly singular, so the solution could not be computed. 💀

Author

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Further Details

The packed storage scheme is illustrated by the following example when N = 4, UPLO = 'U':

Two-dimensional storage of the symmetric matrix A:

   a11 a12 a13 a14
       a22 a23 a24
           a33 a34     (aij = aji)
               a44

Packed storage of the upper triangle of A:

AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ]

subroutine `zspsvx` (character FACT, character UPLO, integer N, integer NRHS, complex16, dimension( ) AP, complex16, dimension( ) AFP, integer, dimension( * ) IPIV, complex16, dimension( ldb, ) B, integer LDB, complex16, dimension( ldx, ) X, integer LDX, double precision RCOND, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR, complex16, dimension( ) WORK, double precision, dimension( * ) RWORK, integer INFO)

subroutine zspsvx (character FACT, character UPLO, integer N, integer NRHS,
    complex*16, dimension( * ) AP, complex*16, dimension( * ) AFP, integer,
    dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer LDB,
    complex*16, dimension( ldx, * ) X, integer LDX, double precision RCOND,
    double precision, dimension( * ) FERR, double precision, dimension( * )
    BERR, complex*16, dimension( * ) WORK, double precision, dimension( * )
    RWORK, integer INFO)

ZSPSVX computes the solution to system of linear equations A * X = B for OTHER matrices 🌸

Purpose

ZSPSVX uses the diagonal pivoting factorization A = U*D*U**T or
A = L*D*L**T to compute the solution to a complex system of linear
equations A * X = B, where A is an N-by-N symmetric matrix stored
in packed format and X and B are N-by-NRHS matrices.

Error bounds on the solution and a condition estimate are also
provided.

Description

The following steps are performed:

If FACT = 'N', the diagonal pivoting method is used to factor A as

   A = U * D * U**T,  if UPLO = 'U', or
   A = L * D * L**T,  if UPLO = 'L',

where U (or L) is a product of permutation and unit upper (lower) triangular matrices and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

If some D(i,i)=0, so that D is exactly singular, then the routine returns with INFO = i. Otherwise, the factored form of A is used to estimate the condition number of the matrix A. If the reciprocal of the condition number is less than machine precision, INFO = N+1 is returned as a warning, but the routine still goes on to solve for X and compute error bounds as described below.
The system of equations is solved for X using the factored form of A. slay ✨
Iterative refinement is applied to improve the computed solution matrix and calculate error bounds and backward error estimates for it. obsessed 💅

Parameters 🎀

FACT — it's a CHARACTER*1 and it's giving "did you already factor A or not?" energy. Specifies whether or not the factored form of A has been supplied on entry.
- = 'F': On entry, AFP and IPIV contain the factored form of A. AP, AFP and IPIV will not be modified.
- = 'N': The matrix A will be copied to AFP and factored. no cap
UPLO — CHARACTER*1, picks which triangle of A we're storing, bestie.
- = 'U': Upper triangle of A is stored; iconic
- = 'L': Lower triangle of A is stored.
N — INTEGER. The number of linear equations, i.e., the order of the matrix A. N >= 0. periodt
NRHS — INTEGER. The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. 💖
AP — COMPLEX*16 array, dimension (N*(N+1)/2). The upper or lower triangle of the symmetric matrix A, packed columnwise in a linear array. The j-th column of A is stored in the array AP as follows:
- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
- if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.
- See below for further details. iykyk
AFP — COMPLEX*16 array, dimension (N*(N+1)/2).
- If FACT = 'F', then AFP is an input argument and on entry contains the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**T or A = L*D*L**T as computed by ZSPTRF, stored as a packed triangular matrix in the same storage format as A.
- If FACT = 'N', then AFP is an output argument and on exit contains the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**T or A = L*D*L**T as computed by ZSPTRF, stored as a packed triangular matrix in the same storage format as A.
IPIV — INTEGER array, dimension (N).
- If FACT = 'F', then IPIV is an input argument and on entry contains details of the interchanges and the block structure of D, as determined by ZSPTRF.
  - If IPIV(k) > 0, then rows and columns k and IPIV(k) were interchanged and D(k,k) is a 1-by-1 diagonal block.
  - If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
  - If UPLO = 'L' and IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
- If FACT = 'N', then IPIV is an output argument and on exit contains details of the interchanges and the block structure of D, as determined by ZSPTRF.
B — COMPLEX*16 array, dimension (LDB,NRHS). The N-by-NRHS right hand side matrix B. main character
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N). ✨
X — COMPLEX*16 array, dimension (LDX,NRHS). If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X. the moment
LDX — INTEGER. The leading dimension of the array X. LDX >= max(1,N). 💅
RCOND — DOUBLE PRECISION. The estimate of the reciprocal condition number of the matrix A. If RCOND is less than the machine precision (in particular, if RCOND = 0), the matrix is singular to working precision. This condition is indicated by a return code of INFO > 0. danger bestie
FERR — DOUBLE PRECISION array, dimension (NRHS). The estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). The estimate is as reliable as the estimate for RCOND, and is almost always a slight overestimate of the true error. we love a good overestimate
BERR — DOUBLE PRECISION array, dimension (NRHS). The componentwise relative backward error of each solution vector X(j) (i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution). slay
WORK — COMPLEX*16 array, dimension (2*N). just vibes
RWORK — DOUBLE PRECISION array, dimension (N). real ones only
INFO — INTEGER.
- = 0: successful exit we ate
- < 0: if INFO = -i, the i-th argument had an illegal value not the vibe
- > 0: if INFO = i, and i is
  - <= N: D(i,i) is exactly zero. The factorization has been completed but the factor D is exactly singular, so the solution and error bounds could not be computed. RCOND = 0 is returned. singularity moment
  - = N+1: D is nonsingular, but RCOND is less than machine precision, meaning that the matrix is singular to working precision. Nevertheless, the solution and error bounds are computed because there are a number of situations where the computed solution can be more accurate than the value of RCOND would suggest. trust the process

Author 🫶

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Further Details: 🌈

The packed storage scheme is illustrated by the following example when N = 4, UPLO = 'U':

Two-dimensional storage of the symmetric matrix A:

   a11 a12 a13 a14
       a22 a23 a24
           a33 a34     (aij = aji)
               a44

Packed storage of the upper triangle of A:

AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ]

Author 🤖

Generated automatically by Doxygen for LAPACK from the source code.

💖 This iconic page comes from LAPACK version 3.11.0, generated on Sun Nov 27 2022, and it's literally complex16OTHERsolve(3). Slay forever. 💅

📦 where this page comes from

debian bookworm: liblapack-doc 3.11.0-2 · BSD-3-Clause
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms

complex16OTHERsolve(3)

💖 complex16OTHERsolve(3) 💖

✨ NAME ✨

🎀 SYNOPSIS 🎀

Functions

🌈 Detailed Description 🌈

🔥 Function Documentation 🔥

💅 subroutine zgglse 💅

Purpose

Parameters

Author

💖 subroutine zhpsv 💖

Purpose

Parameters

Author

Further Details:

zhpsvx 💖

Purpose ✨

Description 🧚

Parameters 🎀

Author 👑

Further Details 💅

zpbsv 🌈

Purpose ✨

Parameters 🍓

✨ Author ✨

🌈 Further Details 🌈

subroutine zpbsvx 🦋

Purpose:

Description:

Parameters

👑 Author 👑

🔍 Further Details:

🧮 subroutine zppsv 🧮

🎯 Purpose:

📋 Parameters

👑 Author 👑

🔍 Further Details:

🧮 subroutine zppsvx 🧮

🎯 Purpose:

📝 Description:

📋 Parameters

EQUED

S

B

LDB

X

LDX

RCOND

FERR

BERR

WORK

RWORK

INFO

Author

Further Details

subroutine zspsv (character UPLO, integer N, integer NRHS, complex*16, dimension( * ) AP, integer, dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer LDB, integer INFO)

Purpose

Parameters

UPLO

N

NRHS

AP

IPIV

B

LDB

INFO

Author

Further Details

Purpose

Description

Parameters 🎀

Author 🫶

Further Details: 🌈

Author 🤖

💅 `subroutine zgglse` 💅

💖 `subroutine zhpsv` 💖

`zhpsvx` 💖

`zpbsv` 🌈

`subroutine zpbsvx` 🦋

🧮 `subroutine zppsv` 🧮

🧮 `subroutine zppsvx` 🧮

subroutine `zspsv` (character UPLO, integer N, integer NRHS, complex16, dimension( ) AP, integer, dimension( * ) IPIV, complex16, dimension( ldb, ) B, integer LDB, integer INFO)