sglgesylv(3)

📦

version 1.1.2 · 3 versions

1.1.2 · fedora 43 (latest)
1.1.1 · fedora 43
1.1.2 · fedora 44

, in fedora 43

🌸 NAME 🌸

<hotpink>sglgesylv</hotpink> — it's the Single Precision page, bestie. MEPACK, section 3, you know the vibe. 💅

Single Precision routines for standard Sylvester equations. That's the whole assignment, periodt.

✨ SYNOPSIS ✨

🫶 Functions 🫶

okay so there are four subroutines on this page and I need you to meet all of them, they're all iconic in their own way:

sla_gesylv — Frontend for the solution of Standard Sylvester Equations.

subroutine sla_gesylv (facta, factb, transa, transb, sgn, m, n, a, lda,
    b, ldb, qa, ldqa, qb, ldqb, x, ldx, scale, work, ldwork, info)

sla_gesylv2 — Frontend for the solution of Standard Sylvester Equations.

subroutine sla_gesylv2 (facta, factb, transa, transb, sgn, m, n, a, lda,
    b, ldb, qa, ldqa, qb, ldqb, x, ldx, scale, work, ldwork, info)

sla_gesylv2_refine — Iterative Refinement for the standard Sylvester Equations.

subroutine sla_gesylv2_refine (transa, transb, guess, sgn, m, n, a, lda,
    b, ldb, x, ldx, y, ldy, as, ldas, bs, ldbs, q, ldq, u, ldu, maxit,
    tau, convlog, work, ldwork, info)

sla_gesylv_refine — Iterative Refinement for the standard Sylvester Equations.

subroutine sla_gesylv_refine (transa, transb, guess, sgn, m, n, a, lda,
    b, ldb, x, ldx, y, ldy, as, ldas, bs, ldbs, q, ldq, u, ldu, maxit,
    tau, convlog, work, ldwork, info)

🦋 Detailed Description 🦋

Single Precision routines for standard Sylvester equations. That's the whole thing. 🎀

This subsection contains the solvers for standard Sylvester equations with general coefficient matrices in single precision arithmetic. The Schur decompositions are computed in single precision with the help of LAPACK. Yes bestie, we're outsourcing the hard part to LAPACK and honestly? slay. 🔥

👑 Function Documentation 👑

🌟 `sla_gesylv` — Frontend for the solution of Standard Sylvester Equations 🌟

Here's the full typed signature, character for character, no cap:

subroutine sla_gesylv (character, dimension(1) facta, character,
    dimension(1) factb, character, dimension(1) transa, character,
    dimension(1) transb, real sgn, integer m, integer n, real,
    dimension(lda,*) a, integer lda, real, dimension(ldb, *) b, integer ldb,
    real, dimension(ldqa, *) qa, integer ldqa, real, dimension(ldqb, *) qb,
    integer ldqb, real, dimension(ldx, *) x, integer ldx, real scale, real,
    dimension(*) work, integer ldwork, integer info)

💖 Purpose 💖

SLA_GESYLV solves a Sylvester equation of one of these two forms:

   op1(A) * X  +  X * op2(B) = SCALE * Y                              (1)

   op1(A) * X  -  X * op2(B) = SCALE * Y                              (2)

where A is a M-by-M matrix and B is a N-by-N matrix. The right hand side Y and the solution X are M-by-N matrices. The matrices A and B can be either a general unreduced matrix, or an upper Hessenberg form, or a (quasi-) upper triangular factor. In the later case QA and QB provide the Schur-vectors of the matrices A and B. 💅

🧚 Parameters 🧚

FACTA

FACTA is CHARACTER. Specifies how the matrix A is given.

== 'N': The matrix A is given as a general matrix and its Schur decomposition A = QA*S*QA**T will be computed.
== 'F': The matrix A is given as its Schur decomposition in terms of S and QA, form A = QA*S*QA**T
== 'H': The matrix A is given as an upper Hessenberg form and its Schur decomposition A = QA*S*QA**T will be computed

FACTB

FACTB is CHARACTER. Specifies how the matrix B is given.

== 'N': The matrix B is given as a general matrix and its Schur decomposition B = QB*R*QB**T will be computed.
== 'F': The matrix B is given as its Schur decomposition in terms of R and QB, form B = QB*R*QB**T
== 'H': The matrix B is given as an upper Hessenberg form and its Schur decomposition B = QB*R*QB**T will be computed

TRANSA

TRANSA is CHARACTER. Specifies the form of the system of equations with respect to A:

== 'N': op1(A) = A
== 'T': op1(A) = A**T

TRANSB

TRANSB is CHARACTER. Specifies the form of the system of equations with respect to B:

== 'N': op2(B) = B,
== 'T': op2(B) = B**T

SGN

SGN is REAL, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.

= 1 : Solve Equation (1)
== -1: Solve Equation (2)

M

M is INTEGER. The order of the matrices A and C. M >= 0.

N

N is INTEGER. The order of the matrices B and D. N >= 0.

A

A is REAL array, dimension (LDA,M).

If FACTA == , the matrix A is a general matrix and it is overwritten with its schur decomposition S.
If FACTA == , the matrix A contains its (quasi-) upper triangular matrix S being the Schur decomposition of A.
If FACTA == , the matrix A is an upper Hessenberg matrix and it is overwritten with its schur decomposition S.

not me noticing the original doc literally leaves the value blank after each FACTA == 😭 bestie I am NOT filling those in for you, that's on the source, we keep it exactly as it is. 🙈

LDA

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

B

B is REAL array, dimension (LDB,N).

If FACTB == , the matrix B is a general matrix and it is overwritten with its schur decomposition R.
If FACTB == , the matrix B contains its (quasi-) upper triangular matrix R being the Schur decomposition of B.
If FACTB == , the matrix B is an upper Hessenberg matrix and it is overwritten with its schur decomposition R.

LDB

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

QA

QA is REAL array, dimension (LDQA,M).

If FACTA == , the matrix QA is an empty M-by-M matrix on input and contains the Schur vectors of A on output.
If FACTA == , the matrix QA contains the Schur vectors of A.
If FACTA == , the matrix QA is an empty M-by-M matrix on input and contains the Schur vectors of A on output.

LDQA

LDQA is INTEGER. The leading dimension of the array QA. LDQA >= max(1,M).

QB

QB is REAL array, dimension (LDQB,N).

If FACTB == , the matrix QB is an empty N-by-N matrix on input and contains the Schur vectors of B on output.
If FACTB == , the matrix QB contains the Schur vectors of B.
If FACTB == , the matrix QB is an empty N-by-N matrix on input and contains the Schur vectors of B on output.

LDQB

LDQB is INTEGER. The leading dimension of the array QB. LDQB >= max(1,N).

X

X is REAL array, dimension (LDX,N).

On input, the matrix X contains the right hand side Y.
On output, the matrix X contains the solution of Equation (1) or (2).

Right hand side Y and the solution X are M-by-N matrices. 💜

LDX

LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).

SCALE

SCALE is REAL. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0, otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.

WORK

WORK is REAL array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optmimal workspace is given either by \ref mepack_memory_frontend or a previous call to the this routine with LDWORK === -1.

LDWORK

LDWORK is INTEGER. Size of the workspace for the algorithm. This can be determined by a call \ref mepack_memory_frontend. Alternatively, if LDWORK == -1 on input, the subroutine will return the required size of the workspace in LDWORK without performing any computations.

INFO

INFO is INTEGER.

== 0: successful exit 🎉
= 1: SHGEES failed
= 2: SLA_SORT_EV failed
= 3: SLA_TRLYAP_DAG failed
< 0: if INFO = -i, the i-th argument had an illegal value

🌈 See also 🌈

SLA_TRSYLV_L3
SLA_TRSYLV_L3_2S
SLA_TRSYLV_DAG
SLA_TRSYLV_L2_UNOPT
SLA_TRSYLV_L2
SLA_TRSYLV_L2_REORDER
SLA_TRSYLV_L2_LOCAL_COPY
SLA_TRSYLV_L2_LOCAL_COPY_32
SLA_TRSYLV_L2_LOCAL_COPY_64
SLA_TRSYLV_L2_LOCAL_COPY_96
SLA_TRSYLV_L2_LOCAL_COPY_128

🎀 Author 🎀

Martin Koehler, MPI Magdeburg

🎀 Date 🎀

October 2025

🎀 Definition 🎀

Definition at line 250 of file sla_gesylv.f90.

🌟 `sla_gesylv2` — Frontend for the solution of Standard Sylvester Equations 🌟

The typed signature, exactly as it appears:

subroutine sla_gesylv2 (character, dimension(1) facta, character,
    dimension(1) factb, character, dimension(1) transa, character,
    dimension(1) transb, real sgn, integer m, integer n, real,
    dimension(lda,*) a, integer lda, real, dimension(ldb, *) b, integer ldb,
    real, dimension(ldqa, *) qa, integer ldqa, real, dimension(ldqb, *) qb,
    integer ldqb, real, dimension(ldx, *) x, integer ldx, real scale, real,
    dimension(*) work, integer ldwork, integer info)

💖 Purpose 💖

SLA_GESYLV2 solves a Sylvester equation of the following forms:

   op1(A) * X * op2(B) +  X  = SCALE * Y                              (1)

   op1(A) * X * op2(B) -  X  = SCALE * Y                              (2)

🧚 Parameters 🧚

FACTA

...okay bestie we are literally mid-parameter here,

FACTA — CHARACTER, and it's the one that decides how the matrix A shows up to the party. 💅
- 'N': A is given as a general matrix, and its Schur decomposition A = QA*S*QA**T will be computed. ✨
- 'F': A is given as its Schur decomposition in terms of S and QA, in the form A = QA*S*QA**T. 🎀
- 'H': A is given as an upper Hessenberg form, and its Schur decomposition A = QA*S*QA**T will be computed. 🌸
FACTB — CHARACTER, same energy but for the matrix B. 🦋
- 'N': B is given as a general matrix, and its Schur decomposition B = QB*R*QB**T will be computed. ✨
- 'F': B is given as its Schur decomposition in terms of R and QB, in the form B = QB*R*QB**T. 🎀
- 'H': B is given as an upper Hessenberg form, and its Schur decomposition B = QB*R*QB**T will be computed. 🌸
TRANSA — CHARACTER. It sets the form of the system of equations with respect to A, bestie:
- 'N': op1(A) = A
- 'T': op1(A) = A**T
TRANSB — CHARACTER. Same deal, but the form of the system of equations with respect to B:
- 'N': op2(B) = B,
- 'T': op2(B) = B**T
SGN — REAL, allowed values: +/-1. It specifies the sign between the two parts of the Sylvester equation. 👑
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — INTEGER. The order of the matrices A and C. M >= 0. ⭐
N — INTEGER. The order of the matrices B and D. N >= 0. ⭐
A — REAL array, dimension (LDA,M). Here's the tea on what it holds depending on the flag:
- If FACTA == , the matrix A is a general matrix and it is overwritten with its schur decomposition S. 💫
- If FACTA == , the matrix A contains its (quasi-) upper triangular matrix S, being the Schur decomposition of A.
- If FACTA == , the matrix A is an upper Hessenberg matrix and it is overwritten with its schur decomposition S. 💫
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M). 🫶
B — REAL array, dimension (LDB,N). Same vibe, for B:
- If FACTB == , the matrix B is a general matrix and it is overwritten with its schur decomposition R. 💫
- If FACTB == , the matrix B contains its (quasi-) upper triangular matrix R, being the Schur decomposition of B.
- If FACTB == , the matrix B is an upper Hessenberg matrix and it is overwritten with its schur decomposition R. 💫
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N). 🫶
QA — REAL array, dimension (LDQA,M). The Schur vectors of A, and whether they come in or go out depends on FACTA:
- If FACTA == , the matrix QA is an empty M-by-M matrix on input and contains the Schur vectors of A on output. 🦋
- If FACTA == , the matrix QA contains the Schur vectors of A.
- If FACTA == , the matrix QA is an empty M-by-M matrix on input and contains the Schur vectors of A on output. 🦋
LDQA — INTEGER. The leading dimension of the array QA. LDQA >= max(1,M). 🫶
QB — REAL array, dimension (LDQB,N). The Schur vectors of B, same rules as above:
- If FACTB == , the matrix QB is an empty N-by-N matrix on input and contains the Schur vectors of B on output. 🦋
- If FACTB == , the matrix QB contains the Schur vectors of B.
- If FACTB == , the matrix QB is an empty N-by-N matrix on input and contains the Schur vectors of B on output. 🦋
LDQB — INTEGER. The leading dimension of the array QB. LDQB >= max(1,N). 🫶
X — REAL array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2). 🔥 Right hand side Y and the solution X are both M-by-N matrices, periodt.
LDX — INTEGER. The leading dimension of the array X. LDX >= max(1,M). 🫶
SCALE — REAL. It's the scaling factor that stops the result from overflowing, because we do not do overflow in this house. 🛑 If INFO == 0 then SCALE is 1.0, otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — REAL array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. 🌈 The optimal workspace is given either by \ref mepack_memory_frontend or by a previous call to this routine with LDWORK === -1. 👀
LDWORK — INTEGER. Size of the workspace for the algorithm. This can be determined by a call to \ref mepack_memory_frontend. Alternatively, if LDWORK == -1 on input, the subroutine will return the required size of the workspace in LDWORK without performing any computations. 🤯 no cap, it just tells you the size and dips.
INFO — INTEGER. The vibe check at the end: 💀
- == 0: successful exit 🎉
- = 1: SHGEES failed 😭
- = 2: SLA_SORT_EV failed 😭
- = 3: SLA_TRLYAP_DAG failed 😭
- < 0: if INFO = -i, the i-th argument had an illegal value 🙈

👀 See also ✨

SLA_TRSYLV2_L3
SLA_TRSYLV2_L3_2S
SLA_TRSYLV2_DAG
SLA_TRSYLV2_L2_UNOPT
SLA_TRSYLV2_L2
SLA_TRSYLV2_L2_REORDER
SLA_TRSYLV2_L2_LOCAL_COPY
SLA_TRSYLV2_L2_LOCAL_COPY_32
SLA_TRSYLV2_L2_LOCAL_COPY_64
SLA_TRSYLV2_L2_LOCAL_COPY_96
SLA_TRSYLV2_L2_LOCAL_COPY_128

👑 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

📍 Definition

At line 250 of file sla_gesylv2.f90.

💖 subroutine sla_gesylv2_refine 💖

subroutine sla_gesylv2_refine (character, dimension(1) transa, character,
    dimension(1) transb, character, dimension(1) guess, real sgn, integer m,
    integer n, real, dimension(lda, *) a, integer lda, real, dimension(ldb,
    *) b, integer ldb, real, dimension ( ldx , * ) x, integer ldx, real,
    dimension(ldy, *) y, integer ldy, real, dimension(ldas, *) as, integer
    ldas, real, dimension(ldbs,*) bs, integer ldbs, real, dimension(ldq, *)
    q, integer ldq, real, dimension(ldu, *) u, integer ldu, integer maxit,
    real tau, real, dimension(*) convlog, real, dimension(*) work, integer
    ldwork, integer info)

Iterative Refinement for the standard Sylvester Equations. 🦋✨

🎯 Purpose

SLA_GESYLV2_REFINE solves a Sylvester equation of the following forms, bestie:

op1(A) * X * op2(B)  +  X = Y                              (1)

op1(A) * X * op2(B)  -  X = Y                              (2)

where A is a M-by-M matrix and B is a N-by-N matrix, using iterative refinement. 🔁 The right hand side Y and the solution X are M-by-N matrices.

The matrix A and B need to be given in the original form as well as in their Schur decomposition, since both are required in the iterative refinement procedure. 💅 like, both versions. don't skimp.

🌸 Parameters 🌸

TRANSA — CHARACTER. Specifies the form of the system of equations with respect to A:
- 'N': op1(A) = A
- 'T': op1(A) = A**T
TRANSB — CHARACTER. Specifies the form of the system of equations with respect to B:
- 'N': op2(B) = B,
- 'T': op2(B) = B**T
GUESS — CHARACTER. Tells us whether X already contains an initial guess or not, iykyk:
- = 'I': X contains an initial guess
- = 'N': No initial guess, X is set to zero at the begin of the iteration. 🫥
SGN — REAL, allowed values: +/-1. Specifies the sign between both terms. ⚖️
M — INTEGER. The order of the matrix A. M >= 0. ⭐
N — INTEGER. The order of the matrix B. N >= 0. ⭐
A — REAL array, dimension (LDA,M). The array A contains the original matrix A defining the equation. 🎀
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M). 🫶
B — REAL array, dimension (LDB,N). The array B contains the original matrix B defining the equation. 🎀
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N). 🫶
X — REAL array, dimension (LDX,N). On input, the array X contains the initial guess, if GUESS = 'I'. On output, the array X contains the solution X. 💖
LDX — INTEGER. The leading dimension of the array X. LDX >= max(1,M). 🫶
Y — REAL array, dimension (LDY,N). On input, the array Y contains the right hand side Y. The array stays unchanged during the iteration. 🧊 (it does not get touched, periodt.)
LDY — INTEGER. The leading dimension of the array Y. LDY >= max(1,M). 🫶
AS — REAL array, dimension (LDAS,M). The array AS contains the Schur decomposition of the A. 🌈
LDAS — INTEGER. The leading dimension of the array AS. LDAS >= max(1,M). 🫶
BS — REAL array, dimension (LDBS,N). The array BS contains the Schur decomposition of B. 🌈
LDBS

okay so the remaining arguments, and yes we are listing every single one of them, no skipping, that's the rule 💅

LDBS — an INTEGER, the leading dimension of the array BS. Constraint: LDBS >= max(1,N).
Q — a REAL array, dimension (LDQ,M). It holds the Schur vectors of A, exactly as SGEES handed them over. ✨
LDQ — an INTEGER, the leading dimension of the array Q. Constraint: LDQ >= max(1,M).
U — a REAL array, dimension (LDU,N). It holds the Schur vectors of B, as returned by SGEES. 🦋
LDU — an INTEGER, the leading dimension of the array U. Constraint: LDU >= max(1,N).
MAXIT — an INTEGER, and it's a glow-up situation because it means two different things at two different times:
- On input, MAXIT is the maximum number of iterations that get performed, and it has to sit in the range 2 <= MAXIT <= 100.
- On exit, MAXIT holds the number of iteration steps the algorithm actually took. 👑
TAU — a REAL, also doing the double-duty thing:
- On input, TAU is the extra security factor for the stopping criterion; typical values are 0.1.
- On exit, TAU holds the last relative residual from the moment the stopping criterion became valid. 🎀
CONVLOG — a REAL array, dimension (MAXIT). This is the receipts, bestie: the convergence history of the iterative refinement. CONVLOG(I) holds the maximum relative residual before it gets solved for the I-th time.
WORK — a REAL array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace comes back in LDWORK if LDWORK == -1 on input — and in that case, no computations happen at all. 🙈
LDWORK — an INTEGER. If LDWORK == -1, the subroutine returns the required size of the workspace in LDWORK on exit. No computations are performed and none of the arrays get referenced. So convenient, honestly.
INFO — an INTEGER, the final vibe check:
- == 0: Success ✨
- > 0: the iteration failed in step INFO 😭
- < 0: if INFO = -i, the i-th argument had an illegal value
- = -50: some of the internal settings like NB, ... are incorrect 💀

🌸 See also 🌸

SLA_TRSYLV2_DAG
DLA_TRSYLV2_LEVEL3
SLA_TRSYLV2_L3_2S
SLA_TRSYLV2_L2_UNOPT
SLA_TRSYLV2_L2
SLA_TRSYLV2_L2_REORDER
SLA_TRSYLV2_L2_LOCAL_COPY_32
SLA_TRSYLV2_L2_LOCAL_COPY_64
SLA_TRSYLV2_L2_LOCAL_COPY_96
SLA_TRSYLV2_L2_LOCAL_COPY_128
SLA_TRSYLV2_L2_LOCAL_COPY

🫶 Author 🫶

Martin Koehler, MPI Magdeburg

📅 Date 📅

October 2025

And for the record, this one is defined at line 271 of file sla_gesylv2_refine.f90. 📍

🦋 `sla_gesylv_refine` — the second one, and she's the star of the show 🦋

   subroutine sla_gesylv_refine (character, dimension(1) transa, character,
       dimension(1) transb, character, dimension(1) guess, real sgn, integer m,
       integer n, real, dimension(lda, *) a, integer lda, real, dimension(ldb,
       *) b, integer ldb, real, dimension ( ldx , * ) x, integer ldx, real,
       dimension(ldy, *) y, integer ldy, real, dimension(ldas, *) as, integer
       ldas, real, dimension(ldbs,*) bs, integer ldbs, real, dimension(ldq, *)
       q, integer ldq, real, dimension(ldu, *) u, integer ldu, integer maxit,
       real tau, real, dimension(*) convlog, real, dimension(*) work, integer
       ldwork, integer info)

Iterative Refinement for the standard Sylvester Equations. That's the whole point of her. 💖

✨ Purpose ✨

okay so SLA_GESYLV_REFINE solves a Sylvester equation, and there are two forms, bestie:

op1(A) * X  +  X * op2(B) = Y                              (1)

op1(A) * X  -  X * op2(B) = Y                              (2)

where A is an M-by-M matrix and B is an N-by-N matrix, and it does it all with iterative refinement. The right hand side Y and the solution X are both M-by-N matrices. 🌈

And here's the part you can't skip: A and B have to be handed over in their original form and in their Schur decomposition, because the iterative refinement procedure literally needs both. No shortcuts, she needs the whole wardrobe. 👑

🎀 Parameters 🎀

TRANSA — a CHARACTER that says which form of the system of equations we're doing with respect to A:
- 'N': op1(A) = A
- 'T': op1(A) = A**T
TRANSB — a CHARACTER, same energy but for B:
- 'N': op2(B) = B,
- 'T': op2(B) = B**T
GUESS — a CHARACTER telling us whether X already has an initial guess in it or not:
- 'I': X contains an initial guess
- 'N': no initial guess — X gets set to zero at the beginning of the iteration
SGN — a REAL, allowed values are +/-1, and it specifies the sign between both terms. That's it, that's the whole job. ✨
M — an INTEGER, the order of the matrix A. Constraint: M >= 0.
N — an INTEGER, the order of the matrix B. Constraint: N >= 0.
A — a REAL array, dimension (LDA,M). It holds the original matrix A that defines the equation. 🦋
LDA — an INTEGER, the leading dimension of the array A. Constraint: LDA >= max(1,M).
B — a REAL array, dimension (LDB,N). It holds the original matrix B that defines the equation.
LDB — an INTEGER, the leading dimension of the array B. Constraint: LDB >= max(1,N).
X — a REAL array, dimension (LDX,N), and she changes:
- On input, X holds the initial guess, but only if GUESS = 'I'.
- On output, X holds the solution X. Slay. 💅
LDX — an INTEGER, the leading dimension of the array X. Constraint: LDX >= max(1,M).
Y — a REAL array, dimension (LDY,N). On input it holds the right hand side Y, and it stays unchanged during the whole iteration. Loyal queen. 🫶
LDY — an INTEGER, the leading dimension of the array Y. Constraint: LDY >= max(1,M).
AS — a REAL array, dimension (LDAS,M). It holds the Schur decomposition of A.
LDAS — an INTEGER, the leading dimension of the array AS. Constraint: LDAS >= max(1,M).
BS — a REAL array, dimension (LDBS,N). It holds the Schur decomposition of B.
LDBS — an INTEGER, the leading dimension of the array BS. Constraint: LDBS >= max(1,N).
Q — a REAL array, dimension (LDQ,M), holding the Schur vectors of A as returned by SGEES. ⭐
LDQ — an INTEGER, the leading dimension of the array Q. Constraint: LDQ >= max(1,M).
U — a REAL array, dimension (LDU,N), holding the Schur vectors of B as returned by SGEES.
LDU — an INTEGER, the leading dimension of the array U. Constraint: LDU >= max(1,N).
MAXIT — an INTEGER, dual purpose as always:
- On input, MAXIT is the maximum number of iterations that are performed, 2 <= MAXIT <= 100
- On exit, MAXIT is the number of iteration steps taken by the algorithm
TAU — a REAL, also dual purpose:
- On input, TAU is the additional security factor for the stopping criterion; typical values are 0.1
- On exit, TAU holds the last relative residual when the stopping criterion got valid
CONVLOG — a REAL array, dimension (MAXIT), the convergence history of the iterative refinement. CONVLOG(I) holds the maximum relative residual before it is solved for the I-th time. 📈
WORK — a REAL array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is returned in LDWORK if LDWORK == -1 on input, and in that case no computations are performed. 🙈
LDWORK — an INTEGER. If LDWORK == -1, the subroutine returns the required size of the workspace in LDWORK on exit. No computations are performed and none of the arrays are referenced.
INFO — an INTEGER, the closing vibe check:
- == 0: Success ✨
- > 0: the iteration failed in step INFO 😭
- < 0: if INFO = -i, the i-th argument had an illegal value
- = -50: some of the internal settings like NB, ... are incorrect 💀

🌸 See also 🌸

SLA_TRSYLV_DAG
DLA_TRSYLV_LEVEL3
SLA_TRSYLV_L3_2S
SLA_TRSYLV_L2_UNOPT
SLA_TRSYLV_L2
SLA_TRSYLV_L2_REORDER
SLA_TRSYLV_L2_LOCAL_COPY_32
SLA_TRSYLV_L2_LOCAL_COPY_64
SLA_TRSYLV_L2_LOCAL_COPY_96
SLA_TRSYLV_L2_LOCAL_COPY_128
SLA_TRSYLV_L2_LOCAL_COPY

🫶 Author 🫶

Martin Koehler, MPI Magdeburg

📅 Date 📅

October 2025

Defined at line 272 of file sla_gesylv_refine.f90. 📍

and that's a wrap on the whole page, bestie 💖 This was generated automatically by Doxygen for MEPACK, straight out of the source code. It's Version 1.1.2, dated Thu Oct 9 2025 00:00:00, and the whole thing lives at page sglgesylv(3). Go refine something iteratively, queen 👑✨

📦 where this page comes from

fedora 43: mepack-devel 1.1.2-1.fc43 · GPL-3.0-or-later and LGPL-2.1-or-later and BSD-3-Clause
fedora 43: mepack-devel 1.1.2-1.fc43 · GPL-3.0-or-later and LGPL-2.1-or-later and 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

sglgesylv(3)

🌸 NAME 🌸

✨ SYNOPSIS ✨

🫶 Functions 🫶

🦋 Detailed Description 🦋

👑 Function Documentation 👑

🌟 sla_gesylv — Frontend for the solution of Standard Sylvester Equations 🌟

💖 Purpose 💖

🧚 Parameters 🧚

🌈 See also 🌈

🎀 Author 🎀

🎀 Date 🎀

🎀 Definition 🎀

🌟 sla_gesylv2 — Frontend for the solution of Standard Sylvester Equations 🌟

💖 Purpose 💖

🧚 Parameters 🧚

👀 See also ✨

👑 Author

📅 Date

📍 Definition

💖 subroutine sla_gesylv2_refine 💖

🎯 Purpose

🌸 Parameters 🌸

🌸 See also 🌸

🫶 Author 🫶

📅 Date 📅

🦋 sla_gesylv_refine — the second one, and she's the star of the show 🦋

✨ Purpose ✨

🎀 Parameters 🎀

🌸 See also 🌸

🫶 Author 🫶

📅 Date 📅

🌟 `sla_gesylv` — Frontend for the solution of Standard Sylvester Equations 🌟

🌟 `sla_gesylv2` — Frontend for the solution of Standard Sylvester Equations 🌟

🦋 `sla_gesylv_refine` — the second one, and she's the star of the show 🦋