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

📦 version 3.12.0, in opensuse-leap 16.0

✨ NAME ✨

/home/abuild/rpmbuild/BUILD/lapack-static-3.12.0-build/lapack-3.12.0/SRC/ztrsyl3.f — bestie, that's the whole name, yes it's a whole path, yes it's giving "I was generated by a build system and I'm proud of it" 💅

This page lives in the <pink>Library Functions Manual</pink>, and the file itself is /home/abui.../ztrsyl3.f(3). Ok so keep that in your pocket.

🌸 SYNOPSIS 🌸

Functions/Subroutines

subroutine ZTRSYL3 (trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc,
    scale, swork, ldswork, info)

ZTRSYL3 — that's the whole vibe, that's the name, periodt ✨

🦋 Function/Subroutine Documentation 🦋

subroutine ZTRSYL3 (character trana, character tranb, integer isgn, integer
    m, integer n, complex*16, dimension( lda, * ) a, integer lda,
    complex*16, dimension( ldb, * ) b, integer ldb, complex*16, dimension(
    ldc, * ) c, integer ldc, double precision scale, double precision,
    dimension( ldswork, * ) swork, integer ldswork, integer info)

Yep. ZTRSYL3. Say it with your chest 👑

🎀 Purpose 🎀

okay so, highkey the whole point:

!>
!>  ZTRSYL3 solves the complex Sylvester matrix equation:
!>
!>     op(A)*X + X*op(B) = scale*C or
!>     op(A)*X - X*op(B) = scale*C,
!>
!>  where op(A) = A or A**H, and  A and B are both upper triangular. A is
!>  M-by-M and B is N-by-N; the right hand side C and the solution X are
!>  M-by-N; and scale is an output scale factor, set <= 1 to avoid
!>  overflow in X.
!>
!>  This is the block version of the algorithm.
!>

So like — op(A) = A or A**H, A and B are both upper triangular, A is M-by-M, B is N-by-N, C and X are both M-by-N, and scale is an output scale factor you set <= 1 to keep X from overflowing. And heads up: this is the block version of the algorithm. Slay 💅

💖 Parameters 💖

TRANA

!>          TRANA is CHARACTER*1
!>          Specifies the option op(A):
!>          = 'N': op(A) = A    (No transpose)
!>          = 'C': op(A) = A**H (Conjugate transpose)
!>
  • 'N' — op(A) = A, no transpose, we're leaving her alone 🫶
  • 'C' — op(A) = A**H, conjugate transpose, flip her and conjugate her 🌈

TRANB

!>          TRANB is CHARACTER*1
!>          Specifies the option op(B):
!>          = 'N': op(B) = B    (No transpose)
!>          = 'C': op(B) = B**H (Conjugate transpose)
!>
  • 'N' — op(B) = B, no transpose ✨
  • 'C' — op(B) = B**H, conjugate transpose 🦋

ISGN

!>          ISGN is INTEGER
!>          Specifies the sign in the equation:
!>          = +1: solve op(A)*X + X*op(B) = scale*C
!>          = -1: solve op(A)*X - X*op(B) = scale*C
!>
  • +1 — solve op(A)*X + X*op(B) = scale*C (plus sign, we're adding 🍓)
  • -1 — solve op(A)*X - X*op(B) = scale*C (minus sign, we're subtracting 💀)

M

!>          M is INTEGER
!>          The order of the matrix A, and the number of rows in the
!>          matrices X and C. M >= 0.
!>

The order of A, and the number of rows in X and C. M >= 0, no cap 📏

N

!>          N is INTEGER
!>          The order of the matrix B, and the number of columns in the
!>          matrices X and C. N >= 0.
!>

The order of B, and the number of columns in X and C. N >= 0, respect the boundaries bestie 🙈

A

!>          A is COMPLEX*16 array, dimension (LDA,M)
!>          The upper triangular matrix A.
!>

It's a COMPLEX*16 array, dimension (LDA,M), and it's the upper triangular matrix A. Only the top part is doing the work, the rest is literally just vibing 🌸

LDA

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

Leading dimension of A. LDA >= max(1,M) — don't come in with a smaller number, I'm warning you 👀

B

!>          B is COMPLEX*16 array, dimension (LDB,N)
!>          The upper triangular matrix B.
!>

COMPLEX*16 array, dimension (LDB,N), the upper triangular matrix B. Same deal, upper triangle only 👑

LDB

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

Leading dimension of B. LDB >= max(1,N) ⭐

C

!>          C is COMPLEX*16 array, dimension (LDC,N)
!>          On entry, the M-by-N right hand side matrix C.
!>          On exit, C is overwritten by the solution matrix X.
!>

COMPLEX*16 array, dimension (LDC,N). On entry she's the M-by-N right hand side matrix C — on exit she's overwritten by the solution matrix X. Not me showing up as one thing and leaving as another 😭 main character transformation fr fr

LDC

!>          LDC is INTEGER
!>          The leading dimension of the array C. LDC >= max(1,M)
!>

Leading dimension of C. LDC >= max(1,M) 💜

SCALE

!>          SCALE is DOUBLE PRECISION
!>          The scale factor, scale, set <= 1 to avoid overflow in X.
!>

DOUBLE PRECISION. The scale factor, scale, set <= 1 to avoid overflow in X. She's protective like that 🫶

SWORK

!>          SWORK is DOUBLE PRECISION array, dimension (MAX(2, ROWS),
!>          MAX(1,COLS)).
!>          On exit, if INFO = 0, SWORK(1) returns the optimal value ROWS
!>          and SWORK(2) returns the optimal COLS.
!>

DOUBLE PRECISION array, dimension (MAX(2, ROWS), MAX(1,COLS)). On exit, if INFO = 0, SWORK(1) returns the optimal value ROWS and SWORK(2) returns the optimal COLS. She's a workspace and a little informant ✨

LDSWORK

!>          LDSWORK is INTEGER
!>          LDSWORK >= MAX(2,ROWS), where ROWS = ((M + NB - 1) / NB + 1)
!>          and NB is the optimal block size.
!>
!>          If LDSWORK = -1, then a workspace query is assumed; the routine
!>          only calculates the optimal dimensions of the SWORK matrix,
!>          returns these values as the first and second entry of the SWORK
!>          matrix, and no error message related LWORK is issued by XERBLA.
!>
  • LDSWORK >= MAX(2,ROWS), where ROWS = ((M + NB - 1) / NB + 1) and NB is the optimal block size 🧚
  • LDSWORK = -1 — workspace query mode, bestie! The routine only calculates the optimal dimensions of the SWORK matrix, returns those values as the first and second entry of the SWORK matrix, and no error message related LWORK is issued by XERBLA. It's giving "just asking, not committing" 🙈

INFO

!>          INFO is INTEGER
!>          = 0: successful exit
!>          < 0: if INFO = -i, the i-th argument had an illegal value
!>          = 1: A and B have common or very close eigenvalues; perturbed
!>               values were used to solve the equation (but the matrices
!>               A and B are unchanged).
!>
  • = 0 — successful exit, we ate and left no crumbs 🔥
  • < 0 — if INFO = -i, the i-th argument had an illegal value. Somebody passed something unserious 💀
  • = 1 — A and B have common or very close eigenvalues; perturbed values were used to solve the equation (but the matrices A and B are unchanged). ok so it panicked a little internally, but externally, no harm, the matrices are literally untouched, we move 😭
ok so real talk: INFO = 1 is one of those "we fixed it behind the scenes, don't worry about it" moments — the perturbed values solved the equation, and A and B stay exactly as you handed them over. No cap.

🌟 Definition at line 155 of file ztrsyl3.f. 🌟

That's where she lives, line 155, iconic address 🎀

💜 Author 💜

Generated automatically by Doxygen for LAPACK from the source code. A bot wrote this. A bot with taste, honestly 🤖💅

ok bye bestie, go solve your complex Sylvester matrix equation, you've got this 🦋✨

— LAPACK, Version 3.12.0, /home/abui.../ztrsyl3.f(3). mwah 💖

📦 where this page comes from