/home/abui.../csytri2.f(3)

📦 version 3.12.0, in opensuse-leap 16.0

💅 csytri2.f(3) — like, the manual page

okay bestie, welcome to the csytri2.f(3) page from the Library Functions Manual — yes the actual file lives at /home/abui.../csytri2.f(3), and we're about to get so acquainted 🫶

✨ NAME ✨

/home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/csytri2.f

that's the whole name, no cap — it's literally just the full path to the source file, and honestly? iconic for that 🌈

🦋 SYNOPSIS 🦋

Functions/Subroutines

  • subroutine CSYTRI2 (uplo, n, a, lda, ipiv, work, lwork, info) — this is the one, the main character of this whole page
    • CSYTRI2

👑 Function/Subroutine Documentation 👑

subroutine CSYTRI2 (character uplo, integer n, complex, dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv, complex, dimension( * ) work, integer lwork, integer info)

CSYTRI2 — say it with me 💅

🎀 Purpose:

!>
!> CSYTRI2 computes the inverse of a COMPLEX symmetric indefinite matrix
!> A using the factorization A = U*D*U**T or A = L*D*L**T computed by
!> CSYTRF. CSYTRI2 sets the LEADING DIMENSION of the workspace
!> before calling CSYTRI2X that actually computes the inverse.
!>

so like — it does the inverse thing, and then it hands the actual math off to CSYTRI2X after fixing up the leading dimension of the workspace first. lowkey a middle-manager routine but we respect the hustle ✨

💜 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*D*U**T;
!>          = 'L':  Lower triangular, form is A = L*D*L**T.
!>

it's one character and it decides everything: 'U' means upper triangular (form is A = U*D*U**T), 'L' means lower triangular (form is A = L*D*L**T). pick your fighter 🥊

N

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

the order of matrix A. and it must be N >= 0 — no negative girlies allowed 🙈

A

!>          A is COMPLEX array, dimension (LDA,N)
!>          On entry, the block diagonal matrix D and the multipliers
!>          used to obtain the factor U or L as computed by CSYTRF.
!>
!>          On exit, if INFO = 0, the (symmetric) inverse of the original
!>          matrix.  If UPLO = 'U', the upper triangular part of the
!>          inverse is formed and the part of A below the diagonal is not
!>          referenced; if UPLO = 'L' the lower triangular part of the
!>          inverse is formed and the part of A above the diagonal is
!>          not referenced.
!>

COMPLEX array, dimension (LDA,N). on entry it's holding the block diagonal matrix D plus the multipliers that gave you U or L, as computed by CSYTRF. on exit — if INFO = 0 — it's the (symmetric) inverse of the original matrix 💖 just know: if UPLO = 'U', only the upper triangular part of the inverse gets formed and everything below the diagonal is simply not referenced; if UPLO = 'L', it's the lower triangular part and everything above the diagonal is not referenced. it's giving "we only look at half the picture" and honestly? efficient 🎀

LDA

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

leading dimension of A, and it's got a floor: LDA >= max(1,N) 🔥

IPIV

!>          IPIV is INTEGER array, dimension (N)
!>          Details of the interchanges and the block structure of D
!>          as determined by CSYTRF.
!>

INTEGER array, dimension (N) — the receipts for the interchanges and the block structure of D, all as determined by CSYTRF 🧾

WORK

!>          WORK is COMPLEX array, dimension (N+NB+1)*(NB+3)
!>

COMPLEX array, dimension (N+NB+1)*(NB+3). that's the size, don't @ me 🫶

LWORK

!>          LWORK is INTEGER
!>          The dimension of the array WORK.
!>          WORK is size >= (N+NB+1)*(NB+3)
!>          If LWORK = -1, then a workspace query is assumed; the routine
!>           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.
!>

INTEGER, the dimension of the array WORK, and WORK is size >= (N+NB+1)*(NB+3). now the fun part 💀 — if LWORK = -1, a workspace query is assumed, and the routine:

  • calculates the optimal size of the WORK array, and returns this value as the first entry of the WORK array,
  • and no error message related to LWORK is issued by XERBLA.

the -1 is basically the "just tell me what you need, bestie" mode ⭐

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) = 0; the matrix is singular and its
!>               inverse could not be computed.
!>

the vibe check at the end:

  • = 0: successful exit, slay ✨
  • < 0: if INFO = -i, the i-th argument had an illegal value, someone fumbled 😭
  • > 0: if INFO = i, then D(i,i) = 0 — the matrix is singular and its inverse could not be computed. no inverse for you, periodt 💀

🧚 Author

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

🌸 Definition at line 126 of file csytri2.f.

🌈 Author (again, but the generated one)

Generated automatically by Doxygen for LAPACK from the source code. not a human, just vibes and a parser 🎀

💖 quick reminder bestie: CSYTRI2 sets the leading dimension of the workspace before calling CSYTRI2X, which is the one that actually computes the inverse — so don't go crediting the wrong subroutine, iykyk 🫶

and that's the page!! LAPACK, Version 3.12.0, dated /home/abui.../csytri2.f(3) — catch you on the next man page, mwah 💅💜

📦 where this page comes from