ZSYSV_AA(3)

💅 NAME

ok so bestie, this page is from the Library Functions Manual and it's all about /home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/zsysv_aa.f — yes that's the whole path, no I'm not shortening it, it's iconic and it's giving "absolute filesystem baddie" 🧚✨

tl;dr: ZSYSV_AA computes the solution to the system of linear equations A * X = B for SY matrices. periodt.

---

✨ SYNOPSIS

Functions/Subroutines

subroutine ZSYSV_AA (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork,
    info)

ZSYSV_AA computes the solution to system of linear equations A * X = B for SY matrices 💖

---

🎀 Function/Subroutine Documentation

subroutine ZSYSV_AA (character uplo, integer n, integer nrhs, complex*16,
    dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv,
    complex*16, dimension( ldb, * ) b, integer ldb, complex*16, dimension( *
    ) work, integer lwork, integer info)

ZSYSV_AA computes the solution to system of linear equations A * X = B for SY matrices 🦋

🌸 Purpose

ok so the actual Purpose block, and I'm quoting it because it's literally the whole vibe:

!>
!> ZSYSV computes the solution to a complex system of linear equations
!>    A * X = B,
!> where A is an N-by-N symmetric matrix and X and B are N-by-NRHS
!> matrices.
!>
!> Aasen's algorithm is used to factor A as
!>    A = U**T * T * U,  if UPLO = 'U', or
!>    A = L * T * L**T,  if UPLO = 'L',
!> where U (or L) is a product of permutation and unit upper (lower)
!> triangular matrices, and T is symmetric tridiagonal. The factored
!> form of A is then used to solve the system of equations A * X = B.
!>

So like — Aasen's algorithm does the factoring, T comes out symmetric tridiagonal, and then that factored form is what actually solves A * X = B. no cap, that's the whole tea ☕✨

---

🦋 Parameters

🌈 UPLO

!>          UPLO is CHARACTER*1
!>          = 'U':  Upper triangle of A is stored;
!>          = 'L':  Lower triangle of A is stored.
!>

UPLO is a CHARACTER*1 and you get exactly two choices, bestie: 'U' means the upper triangle of A is the one being stored, 'L' means it's the lower triangle. choose wisely 💅

🍓 N

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

N is INTEGER, the number of linear equations — literally the order of the matrix A. constraint: N >= 0. ✨

🧚 NRHS

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

NRHS is INTEGER, the number of right hand sides, a.k.a. how many columns the matrix B has. constraint: NRHS >= 0. 🫶

👑 A

!>          A is COMPLEX*16 array, dimension (LDA,N)
!>          On entry, the symmetric matrix A.  If UPLO = 'U', the leading
!>          N-by-N upper triangular part of A contains the upper
!>          triangular part of the matrix A, and the strictly lower
!>          triangular part of A is not referenced.  If UPLO = 'L', the
!>          leading N-by-N lower triangular part of A contains the lower
!>          triangular part of the matrix A, and the strictly upper
!>          triangular part of A is not referenced.
!>
!>          On exit, if INFO = 0, the tridiagonal matrix T and the
!>          multipliers used to obtain the factor U or L from the
!>          factorization A = U**T*T*U or A = L*T*L**T as computed by
!>          ZSYTRF.
!>

A is a COMPLEX*16 array, dimension (LDA,N), and she's doing double duty:

• On entry — the symmetric matrix A. If UPLO = 'U', the leading N-by-N upper triangular part of A holds the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A holds the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. (the unreferenced half is just vibing, leave it alone 🙈)
• On exit — if INFO = 0, you get the tridiagonal matrix T and the multipliers used to obtain the factor U or L from the factorization A = U**T*T*U or A = L*T*L**T as computed by ZSYTRF. slay 💜

⭐ LDA

!>          LDA is INTEGER
!>          The leading dimension of the array A.  LDA >= max(1,N).
!>

LDA is INTEGER, the leading dimension of the array A. requirement: LDA >= max(1,N). 🎀

🔥 IPIV

!>          IPIV is INTEGER array, dimension (N)
!>          On exit, it contains the details of the interchanges, i.e.,
!>          the row and column k of A were interchanged with the
!>          row and column IPIV(k).
!>

IPIV is an INTEGER array, dimension (N). On exit it's holding the details of the interchanges — meaning the row and column k of A were interchanged with the row and column IPIV(k). the receipts of who swapped with whom 📋✨

🌸 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.
!>

B is a COMPLEX*16 array, dimension (LDB,NRHS). On entry she's the N-by-NRHS right hand side matrix B. On exit, if INFO = 0, she IS the N-by-NRHS solution matrix X. glow-up arc, honestly 😭💖

🦋 LDB

!>          LDB is INTEGER
!>          The leading dimension of the array B.  LDB >= max(1,N).
!>

LDB is INTEGER, the leading dimension of the array B. requirement: LDB >= max(1,N). ⭐

💜 WORK

!>          WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))
!>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
!>

WORK is a COMPLEX*16 array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK — she's a workspace and a messenger 🫶

🌈 LWORK

!>          LWORK is INTEGER
!>          The length of WORK.  LWORK >= MAX(1,2*N,3*N-2), and for
!>          the best performance, LWORK >= MAX(1,N*NB), where NB is
!>          the optimal blocksize for ZSYTRF_AA.
!>
!>          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.
!>

LWORK is INTEGER, the length of WORK. minimum is LWORK >= MAX(1,2*N,3*N-2), but for the best performance you want LWORK >= MAX(1,N*NB), where NB is the optimal blocksize for ZSYTRF_AA. treat yourself to the extra workspace 💅

🚨 and listen: 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 get this — no error message related to LWORK is issued by XERBLA. it's the one time XERBLA minds her business 😌

🎀 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.
!>

INFO is INTEGER and it's the vibe check at the end:

• = 0 — successful exit, we ate 👑
• < 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.

Definition at line 160 of file zsysv_aa.f. 📍

---

💖 Author (the other one)

Generated automatically by Doxygen for LAPACK from the source code. 🤖✨

---

ok that's the whole page bestie, go forth and solve symmetric systems 🦋💅

LAPACK — Version 3.12.0 — and the file is /home/abui.../zsysv_aa.f(3), mwah 💋