SRC/dsytrs_aa.f(3)

💅 SRC/dsytrs_aa.f(3) — from the Library Functions Manual bestie 🎀

okay so this is the page for SRC/dsytrs_aa.f, and it's literally the solve step you've been waiting for ✨

---

✨ SYNOPSIS ✨

🌸 Functions/Subroutines

• subroutine dsytrs_aa (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) — the one and only DSYTRS_AA 🫶

🦋 Function/Subroutine Documentation

subroutine dsytrs_aa (character uplo, integer n, integer nrhs, double
    precision, dimension( lda, * ) a, integer lda, integer, dimension( * )
    ipiv, double precision, dimension( ldb, * ) b, integer ldb, double
    precision, dimension( * ) work, integer lwork, integer info)

DSYTRS_AA — say it with me 👑 (that's the name, no cap)

💖 Purpose:

!>
!> DSYTRS_AA solves a system of linear equations A*X = B with a real
!> symmetric matrix A using the factorization A = U**T*T*U or
!> A = L*T*L**T computed by DSYTRF_AA.
!>

so basically: you already did the factorization with DSYTRF_AA, and now this routine takes that and actually solves A*X = B for your real symmetric matrix A 🔥 it's giving "the sequel that ate" fr fr

---

🌈 Parameters 🌈

🍓 UPLO

!>          UPLO is CHARACTER*1
!>          Specifies whether the details of the factorization are stored
!>          as an upper or lower triangular matrix.
!>          = 'U':  Upper triangular, form is A = U**T*T*U;
!>          = 'L':  Lower triangular, form is A = L*T*L**T.
!>

UPLO is a CHARACTER*1 and it tells you where the factorization details live — upper or lower triangular, pick your fighter 💅

• 'U' → upper triangular, form is A = U**T*T*U
• 'L' → lower triangular, form is A = L*T*L**T

🌸 N

!>          N is INTEGER
!>          The order of the matrix A.  N >= 0.
!>

N is INTEGER, the order of matrix A, and it must be 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 — how many right hand sides you got, aka the number of columns of matrix B, and NRHS >= 0 🫶

🎀 A

!>          A is DOUBLE PRECISION array, dimension (LDA,N)
!>          Details of factors computed by DSYTRF_AA.
!>

A is a DOUBLE PRECISION array, dimension (LDA,N) — it's holding the details of the factors that DSYTRF_AA computed 👑

⭐ LDA

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

LDA is INTEGER, the leading dimension of array A, and you need LDA >= max(1,N) no exceptions bestie 🙈

💜 IPIV

!>          IPIV is INTEGER array, dimension (N)
!>          Details of the interchanges as computed by DSYTRF_AA.
!>

IPIV is an INTEGER array, dimension (N), holding the details of the interchanges — again, as computed by DSYTRF_AA 🔁

🌸 B

!>          B is DOUBLE PRECISION array, dimension (LDB,NRHS)
!>          On entry, the right hand side matrix B.
!>          On exit, the solution matrix X.
!>

B is a DOUBLE PRECISION array, dimension (LDB,NRHS) — glow-up moment incoming: on entry it's the right hand side matrix B, and on exit it's the solution matrix X 🦋✨ literally the transformation arc

🧚 LDB

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

LDB is INTEGER, the leading dimension of array B, with LDB >= max(1,N) 🎀

💖 WORK

!>          WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
!>

WORK is a DOUBLE PRECISION array, dimension (MAX(1,LWORK)) — the workspace, the backstage crew of this whole operation 💅

🔥 LWORK

!>          LWORK is INTEGER
!>          The dimension of the array WORK.
!>          If MIN(N,NRHS) = 0, LWORK >= 1, else LWORK >= 3*N-2.
!>
!>          If LWORK = -1, then a workspace query is assumed; the routine
!>          only calculates the minimal 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 dimension of the array WORK 🫶 and here's the tea:

• if MIN(N,NRHS) = 0, then LWORK >= 1
• else LWORK >= 3*N-2

and the fun part 🎀 if LWORK = -1, a workspace query is assumed — the routine only calculates the minimal size of the WORK array, returns this value as the first entry of the WORK array, and XERBLA issues no error message related to LWORK ⭐ so don't panic, it's on purpose

🌈 INFO

!>          INFO is INTEGER
!>          = 0:  successful exit
!>          < 0:  if INFO = -i, the i-th argument had an illegal value
!>

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

• = 0: successful exit 🎉 slay
• < 0: if INFO = -i, the i-th argument had an illegal value 🙈

---

👑 Author

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

Definition at line 135 of file dsytrs_aa.f. 📍

---

💜 Author (the meta one)

Generated automatically by Doxygen for LAPACK from the source code 🤖✨ (yes, even the docs got a glow-up from a robot, iykyk)

---

fr fr if LWORK isn't big enough you're gonna have a bad time — respect the 3*N-2, bestie 😭

---

that's the whole page!! 🫶 this was LAPACK, Version 3.12.0, comin' at you from SRC/dsytrs_aa.f(3) — mwah, go solve something iconic 💋✨