residual(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 🌸

okay so this is residual(3) from MEPACK — yes bestie, the math library manual, section 3, we're doing this 💖

Residual Computations

This collection computes the relative residuals of the matrix equations.

✨ SYNOPSIS ✨

🎀 Topics 🎀

🦋 C-Interface 🦋

C-Interface for the residual computations.

🌈 Functions 🌈

double precision function dla_residual_csylv (transa, transb, sgn1, sgn2, m, n, a, lda, b, ldb, c, ldc, d, ldd, r, ldr, l, ldl, e, lde, f, ldf, scale) — Compute the relative residual for the coupled Sylvester equation.
double precision function dla_residual_csylv_dual (transa, transb, sgn1, sgn2, m, n, a, lda, b, ldb, c, ldc, d, ldd, r, ldr, l, ldl, e, lde, f, ldf, scale) — Compute the relative residual for the dual coupled Sylvester equation.
double precision function dla_residual_glyap (trans, m, a, lda, b, ldb, x, ldx, y, ldy, scale) — Compute the relative residual for the generalized Lyapunov equation.
double precision function dla_residual_gstein (trans, m, a, lda, b, ldb, x, ldx, y, ldy, scale) — Compute the relative residual for the generalized Stein equation.
double precision function dla_residual_gsylv (transa, transb, sgn, m, n, a, lda, b, ldb, c, ldc, d, ldd, x, ldx, y, ldy, scale) — Compute the relative residual for the generalized Sylvester equation.
double precision function dla_residual_lyap (trans, m, a, lda, x, ldx, y, ldy, scale) — Compute the relative residual for the Lyapunov equation.
double precision function dla_residual_stein (trans, m, a, lda, x, ldx, y, ldy, scale) — Compute the relative residual for the Stein equation.
double precision function dla_residual_sylv (transa, transb, sgn, m, n, a, lda, b, ldb, x, ldx, y, ldy, scale) — Compute the relative residual for the Sylvester equation.
double precision function dla_residual_sylv2 (transa, transb, sgn, m, n, a, lda, b, ldb, x, ldx, y, ldy, scale) — Compute the relative residual for the discrete-time Sylvester equation.
real function sla_residual_csylv (transa, transb, sgn1, sgn2, m, n, a, lda, b, ldb, c, ldc, d, ldd, r, ldr, l, ldl, e, lde, f, ldf, scale) — Compute the relative residual for the coupled Sylvester equation.
real function sla_residual_csylv_dual (transa, transb, sgn1, sgn2, m, n, a, lda, b, ldb, c, ldc, d, ldd, r, ldr, l, ldl, e, lde, f, ldf, scale) — Compute the relative residual for the dual coupled Sylvester equation.
real function sla_residual_glyap (trans, m, a, lda, b, ldb, x, ldx, y, ldy, scale) — Compute the relative residual for the generalized Lyapunov equation.
real function sla_residual_gstein (trans, m, a, lda, b, ldb, x, ldx, y, ldy, scale) — Compute the relative residual for the generalized Stein equation.
real function sla_residual_gsylv (transa, transb, sgn, m, n, a, lda, b, ldb, c, ldc, d, ldd, x, ldx, y, ldy, scale) — Compute the relative residual for the generalized Sylvester equation.
real function sla_residual_lyap (trans, m, a, lda, x, ldx, y, ldy, scale) — Compute the relative residual for the Lyapunov equation.
real function sla_residual_stein (trans, m, a, lda, x, ldx, y, ldy, scale) — Compute the relative residual for the Stein equation.
real function sla_residual_sylv (transa, transb, sgn, m, n, a, lda, b, ldb, x, ldx, y, ldy, scale) — Compute the relative residual for the Sylvester equation.
real function sla_residual_sylv2 (transa, transb, sgn, m, n, a, lda, b, ldb, x, ldx, y, ldy, scale) — Compute the relative residual for the discrete-time Sylvester equation.

ok so real quick: the dla_ ones are the double precision girlies and the sla_ ones are the single precision girlies. same energy, different precision 💅

🌺 Detailed Description 🌺

This collection computes the relative residuals of the matrix equations.

So basically, the routines in this group compute the relative residuals of the matrix equations. And here's the part that ate 💅 — unlike the computational routines, these ones manage the memory on their own, which makes them way easier to use from both Fortran and C. No manual allocation drama, no cap. 🎀

👑 Function Documentation 👑

💖 double precision function dla_residual_csylv 💖

double precision function dla_residual_csylv (character transa, character
    transb, double precision sgn1, double precision sgn2, integer m, integer
    n, double precision, dimension(lda, *) a, integer lda, double precision,
    dimension(ldb, *) b, integer ldb, double precision, dimension(ldc,*) c,
    integer ldc, double precision, dimension(ldd, *) d, integer ldd, double
    precision, dimension(ldr, *) r, integer ldr, double precision,
    dimension(ldl, *) l, integer ldl, double precision, dimension(lde, *) e,
    integer lde, double precision, dimension(ldf, *) f, integer ldf, double
    precision scale)

Compute the relative residual for the coupled Sylvester equation.

⭐ Purpose:

!>
!> Compute the relative residual of the coupled Sylvester equation
!>
!>  RelRes = max( || SCALE*E - opA(A)*R - SGN1 * L *opB(B) || / ( (||A||*||R||+||B||*||L||) + SCALE * ||E|| ),
!>                || SCALE*F - opA(C)*R - SGN2 * L *opB(D) || / ( (||C||*||R||+||D||*||L||) + SCALE * ||F|| ))    (1)
!>
!> The norms are evaluated in terms of the Frobenius norm.
!>

🫶 Remarks

Auxiliary memory is managed by the function itself. (iconic behaviour honestly, she handles her own business ✨)

🎀 Parameters

TRANSA

!>          TRANSA is CHARACTER(1)
!>          Specifies the form of the system of equations with respect to A :
!>          == 'N':  opA(A) = A (No transpose for A)
!>          == 'T':  opA(A) = A**T (Transpose A)
!>

TRANSB

!>          TRANSB is CHARACTER(1)
!>          Specifies the form of the system of equations with respect to B :
!>          == 'N':  opB(B) = B (No transpose for B)
!>          == 'T':  opB(B) = B**T (Transpose B)
!>

SGN1

!>          SGN1 is DOUBLE PRECISION, allowed values: +/-1
!>          Specifies the sign between the two parts of the first equation.
!>

SGN2

!>          SGN2 is DOUBLE PRECISION, allowed values: +/-1
!>          Specifies the sign between the two parts of the second equation.
!>

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

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

!>          A is DOUBLE PRECISION array, dimension (LDA,M)
!>          The coefficient matrix A.
!>

LDA

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

!>          B is DOUBLE PRECISION array, dimension (LDB,N)
!>          The coefficient matrix B.
!>

LDB

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

!>          C is DOUBLE PRECISION array, dimension (LDC,M)
!>          The coefficient matrix C.
!>

LDC

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

!>          D is DOUBLE PRECISION array, dimension (LDD,N)
!>          The coefficient matrix D.
!>

LDD

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

!>          R is DOUBLE PRECISION array, dimension (LDR,N)
!>          First part of the solution of the Sylvester Equation.
!>

LDR

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

!>          L is DOUBLE PRECISION array, dimension (LDL,N)
!>          Second part of the solution of the Sylvester Equation.
!>

LDL

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

!>          E is DOUBLE PRECISION array, dimension (LDE,N)
!>          The first right hand side of the Sylvester Equation.
!>

LDE

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

!>          F is DOUBLE PRECISION array, dimension (LDF,N)
!>          The second right hand side of the Sylvester Equation.
!>

LDF

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

SCALE

!>          SCALE is DOUBLE PRECISION
!>          SCALE is a scaling factor to prevent the overflow in the result.
!>

🌟 Returns

!>          The function returns the relative residual as defined in (1). If an error
!>          occurs a negative integer I is returned, signalizing that the parameter -I
!>          has a wrong/illegal value. If I = -1000, the auxiliary memory could not be allocated.
!> .fi

ok so heads up bestie 🚨 if you get a negative number back that's NOT a residual, that's a cry for help. -I means the parameter I was wrong/illegal, and specifically I = -1000 means the auxiliary memory could not be allocated. read the room and check your args 💀

🧚 Author

Martin Koehler, MPI Magdeburg

🎀 Date

October 2025

Definition at line 204 of file res_csylv.f90.

💖 double precision function dla_residual_csylv_dual 💖

double precision function dla_residual_csylv_dual (character transa,
    character transb, double precision sgn1, double precision sgn2, integer
    m, integer n, double precision, dimension(lda, *) a, integer lda, double
    precision, dimension(ldb, *) b, integer ldb, double precision,
    dimension(ldc,*) c, integer ldc, double precision, dimension(ldd, *) d,
    integer ldd, double precision, dimension(ldr, *) r, integer ldr, double
    precision, dimension(ldl, *) l, integer ldl, double precision,
    dimension(lde, *) e, integer lde, double precision, dimension(ldf, *) f,
    integer ldf, double precision scale)

Compute the relative residual for the dual coupled Sylvester equation.

⭐ Purpose:

!>
!> Compute the relative residual of the dual coupled Sylvester equation
!>
!>  RelRes = max( || SCALE*E - opA(A)**T *R - opA(C) ** T *L || / ( (||A||*||R||+||C||*||L||) + SCALE * ||E|| ),
!>                || SCALE*F - SGN1 * R  * opB(B)**T - SGN2 * L * opB(D) **T || / ( (||B||*||R||+||D||*||L||) + SCALE * ||F||)) (1)
!>
!> The norms are evaluated in terms of the Frobenius norm.
!>

🫶 Remarks

Auxiliary memory is managed by the function itself. (she's independent, she's self-sufficient, she allocates her own aux memory 💅✨)

🎀 Parameters

TRANSA

!>          TRANSA is CHARACTER(1)
!>          Specifies the form of the system of equations with respect to A :
!>          == 'N':  opA(A) = A (No transpose for A)
!>          == 'T':  opA(A) = A**T (Transpose A)
!>

TRANSB

!>          TRANSB is CHARACTER(1)
!>          Specifies the form of the system of equations with respect to B :
!>          == 'N':  opB(B) = B (No transpose for B)
!>          == 'T':  opB(B) = B**T (Transpose B)
!>

SGN1

SGN1 — DOUBLE PRECISION, and the only values allowed are +/-1. It sets the sign that sits between the two parts of the first equation. That's the whole job. Slay. ✨
SGN2 — DOUBLE PRECISION, allowed values +/-1 again. This one is the sign between the two parts of the second equation.
M — INTEGER, the order of the matrix A. And it's M >= 0, no negatives bestie. 🎀
N — INTEGER, the order of the matrix B. N >= 0.
A — DOUBLE PRECISION array, dimension (LDA,M). It's the coefficient matrix A, obviously. 💅
LDA — INTEGER, the leading dimension of the array A. LDA >= max(1,M).
B — DOUBLE PRECISION array, dimension (LDB,N). The coefficient matrix B.
LDB — INTEGER, the leading dimension of the array A (that's literally what the page says — it means the one paired with B, we are NOT editing the source 🙈). LDB >= max(1,N).
C — DOUBLE PRECISION array, dimension (LDC,M). The coefficient matrix C.
LDC — INTEGER, the leading dimension of the array C. LDC >= max(1,M).
D — DOUBLE PRECISION array, dimension (LDD,N). The coefficient matrix D.
LDD — INTEGER, and yes, the text here says "the leading dimension of the array A" again — quoted faithfully, no cap. LDD >= max(1,N).
R — DOUBLE PRECISION array, dimension (LDR,N). First part of the solution of the Sylvester Equation. main character part, honestly. 👑
LDR — INTEGER, the leading dimension of the array R. LDR >= max(1,M).
L — DOUBLE PRECISION array, dimension (LDL,N). Second part of the solution of the Sylvester Equation.
LDL — INTEGER, the leading dimension of the array L. LDL >= max(1,M).
E — DOUBLE PRECISION array, dimension (LDE,N). The first right hand side of the Sylvester Equation.
LDE — INTEGER, the leading dimension of the array E. LDE >= max(1,M).
F — DOUBLE PRECISION array, dimension (LDF,N). The second right hand side of the Sylvester Equation.
LDF — INTEGER, the leading dimension of the array F. LDF >= max(1,M).
SCALE — DOUBLE PRECISION. It's a scaling factor, and its whole personality is preventing overflow in the result. 🫶

Returns

The function hands you back the relative residual, exactly as defined in (1). But if something goes wrong, it returns a negative integer I, which is its way of signalizing that the parameter -I has a wrong/illegal value. And if I = -1000, the auxiliary memory could not be allocated. 😭

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 204 of file res_csylv_dual.f90.

💖 `dla_residual_glyap` 💖

double precision function dla_residual_glyap (character trans, integer m,
    double precision, dimension(lda, *) a, integer lda, double precision,
    dimension(ldb, *) b, integer ldb, double precision, dimension(ldx, *) x,
    integer ldx, double precision, dimension(ldy, *) y, integer ldy, double
    precision scale)

Compute the relative residual for the generalized Lyapunov equation. 🌸

Purpose

It computes the relative residual of the Lyapunov equation:

RelRes = || SCALE*Y - op(A)*X*op(B)**T - op(B) * X * op(A)**T || / ( 2*||A||*||B||*||X|| + SCALE * ||Y|| )     (1)

And the norms? All evaluated in terms of the Frobenius norm. Periodt. ✨

Remarks

Auxiliary memory is managed by the function itself. It's giving self-sufficient. 💅

Parameters

TRANS — CHARACTER(1). Specifies the form of the system of equations with respect to A:
- == 'N': op(A) = A (No transpose for A)
- == 'T': op(A) = A**T (Transpose A)
M — INTEGER, the order of the matrix A. M >= 0.
A — DOUBLE PRECISION array, dimension (LDA,M). The coefficient matrix A.
LDA — INTEGER, the leading dimension of the array A. LDA >= max(1,M).
B — DOUBLE PRECISION array, dimension (LDB,M). The coefficient matrix B.
LDB — INTEGER, the leading dimension of the array B. LDB >= max(1,M).
X — DOUBLE PRECISION array, dimension (LDX,M). Solution of the Lyapunov Equation. 💖
LDX — INTEGER, the leading dimension of the array X. LDX >= max(1,M).
Y — DOUBLE PRECISION array, dimension (LDY,M). The right hand side of the Lyapunov Equation.
LDY — INTEGER, the leading dimension of the array Y. LDY >= max(1,M).
SCALE — DOUBLE PRECISION. A scaling factor to prevent the overflow in the result. 🫶

Returns

The relative residual as defined in (1). If an error occurs, a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value. If I = -1000, the auxiliary memory could not be allocated. 💀

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 129 of file res_glyap.f90.

🦋 `dla_residual_gstein` 🦋

double precision function dla_residual_gstein (character trans, integer m,
    double precision, dimension(lda, *) a, integer lda, double precision,
    dimension(ldb, *) b, integer ldb, double precision, dimension(ldx, *) x,
    integer ldx, double precision, dimension(ldy, *) y, integer ldy, double
    precision scale)

Compute the relative residual for the generalized Stein equation. 🌈

Purpose

It computes the relative residual of the Stein equation:

RelRes = || SCALE*Y - op(A)*X*op(A)**T + op(B) * X * op(B)**T || / ( (||A||**2+||B||**2)*||X|| + SCALE * ||Y|| )     (1)

Norms? Frobenius norm, always. ⭐

Remarks

Auxiliary memory is managed by the function itself. Again. Iconic behaviour. 💅

Parameters

TRANS — CHARACTER(1). Specifies the form of the system of equations with respect to A:
- == 'N': op(A) = A (No transpose for A)
- == 'T': op(A) = A**T (Transpose A)
M — INTEGER, the order of the matrix A. M >= 0.
A — DOUBLE PRECISION array, dimension (LDA,M). The coefficient matrix A.
LDA — INTEGER, the leading dimension of the array A. LDA >= max(1,M).
B — DOUBLE PRECISION array, dimension (LDB,M). The coefficient matrix B.
LDB — INTEGER, the leading dimension of the array B. LDB >= max(1,M).
X — DOUBLE PRECISION array, dimension (LDX,M). Solution of the Stein Equation. 🎀
LDX — INTEGER, the leading dimension of the array X. LDX >= max(1,M).
Y — DOUBLE PRECISION array, dimension (LDY,M). The right hand side of the Stein Equation.
LDY — INTEGER, the leading dimension of the array Y. LDY >= max(1,M).
SCALE — DOUBLE PRECISION. A scaling factor to prevent the overflow in the result. 🫶

Returns

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 129 of file res_gstein.f90.

✨ `dla_residual_gsylv` ✨

double precision function dla_residual_gsylv (character transa, character
    transb, double precision sgn, integer m, integer n, double precision,
    dimension(lda, *) a, integer lda, double precision, dimension(ldb, *) b,
    integer ldb, double precision, dimension(ldc,*) c, integer ldc, double
    precision, dimension(ldd, *) d, integer ldd, double precision,
    dimension(ldx, *) x, integer ldx, double precision, dimension(ldy, *) y,
    integer ldy, double precision scale)

Compute the relative residual for the generalized Sylvester equation. 🔥

Purpose

It computes the relative residual of the generalized Sylvester equation:

RelRes = || SCALE*Y - opA(A)*X*opB(B) - SGN * opA(C) * X opB(D) ) || / ( (||A||*||B||+||C||*||D||)*||X|| + SCALE * ||Y|| )  (1)

Frobenius norm for all the norms, iykyk. 💜

Remarks

Auxiliary memory is managed by the function itself.

Parameters

TRANSA — CHARACTER(1). Specifies the form of the system of equations with respect to A:
- == 'N': opA(A) = A (No transpose for A)
- == 'T': opA(A) = A**T (Transpose A)
TRANSB — CHARACTER(1). Specifies the form of the system of equations with respect to B:
- == 'N': opB(B) = B (No transpose for B)
- == 'T': opB(B) = B**T (Transpose B)
SGN — DOUBLE PRECISION, allowed values +/-1. Specifies the sign between the two parts of the Sylvester equation.
M — INTEGER, the order of the matrix A. M >= 0.
N — and this is where the page hands off to the next part, bestie — the file literally stops right here mid-list, so we pick it back up in the next chunk 💅
N — INTEGER, bestie. The order of the matrix B. And N >= 0, obviously, we don't do negative orders here 💅

A

DOUBLE PRECISION array, dimension (LDA,M) — the coefficient matrix A. That's her.

LDA

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

B

DOUBLE PRECISION array, dimension (LDB,N) — the coefficient matrix B. Iconic.

LDB

INTEGER — "the leading dimension of the array A." LDB >= max(1,N). Yes, it literally says A. Not me, not my business, moving on 🫶

C

DOUBLE PRECISION array, dimension (LDC,M) — the coefficient matrix C.

LDC

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

D

DOUBLE PRECISION array, dimension (LDD,N) — the coefficient matrix D.

LDD

INTEGER — again "the leading dimension of the array A." LDD >= max(1,N). Same energy as LDB. Whatever, we keep it 💀

X

DOUBLE PRECISION array, dimension (LDX,N) — the solution of the Sylvester Equation. The main character fr.

LDX

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

Y

DOUBLE PRECISION array, dimension (LDY,N) — the right hand side of the Sylvester Equation.

LDY

INTEGER — the leading dimension of the array Y. LDY >= max(1,M).

SCALE

DOUBLE PRECISION — a scaling factor, and the whole point of her existence is preventing overflow in the result. A true guardian angel 🧚

✨ Returns ✨

The function returns the relative residual as defined in (1). If an error occurs a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value. If I = -1000, the auxiliary memory could not be allocated.

!> .fi

👑 Author 👑

Martin Koehler, MPI Magdeburg

🎀 Date 🎀

October 2025

🦋 Definition 🦋

At line 172 of file res_gsylv.f90.

💜 And now… the rest of the double precision functions 💜

double precision function dla_residual_lyap (character trans, integer m,
    double precision, dimension(lda, *) a, integer lda, double precision,
    dimension(ldx, *) x, integer ldx, double precision, dimension(ldy, *) y,
    integer ldy, double precision scale)

Compute the relative residual for the Lyapunov equation. Obsessed.

🌸 Purpose 🌸

!>
!> Compute the relative residual of the Lyapunov equation
!>
!>     RelRes = || SCALE*Y - op(A)*X - X * op(A)**T || / ( 2*||A||*||X|| + SCALE * ||Y|| )     (1)
!>
!> The norms are evaluated in terms of the Frobenius norm.
!>

🫶 Remarks 🫶

Auxiliary memory is managed by the function itself. She handles her own business, no cap.

✨ Parameters ✨

TRANS

CHARACTER(1) — specifies the form of the system of equations with respect to A:
- 'N': op(A) = A (no transpose for A)
- 'T': op(A) = A**T (transpose A)

M

INTEGER — the order of the matrix A. M >= 0.

A

DOUBLE PRECISION array, dimension (LDA,M) — the coefficient matrix A.

LDA

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

X

DOUBLE PRECISION array, dimension (LDX,M) — the solution of the Lyapunov Equation.

LDX

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

Y

DOUBLE PRECISION array, dimension (LDY,M) — the right hand side of the Lyapunov Equation.

LDY

INTEGER — the leading dimension of the array Y. LDY >= max(1,M).

SCALE

DOUBLE PRECISION — a scaling factor to prevent the overflow in the result. Again, the overflow-prevention queen 💅

✨ Returns ✨

The function returns the relative residual as defined in (1). If an error occurs a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value. If I = -1000, the auxiliary memory could not be allocated.

!> .fi

👑 Author 👑

Martin Koehler, MPI Magdeburg

🎀 Date 🎀

October 2025

🦋 Definition 🦋

At line 116 of file res_lyap.f90.

double precision function dla_residual_stein (character trans, integer m,
    double precision, dimension(lda, *) a, integer lda, double precision,
    dimension(ldx, *) x, integer ldx, double precision, dimension(ldy, *) y,
    integer ldy, double precision scale)

Compute the relative residual for the Stein equation. She's here and she ate ✨

🌸 Purpose 🌸

!>
!> Compute the relative residual of the Stein equation
!>
!>     RelRes = || SCALE*Y - op(A)*X*op(A)**T + X || / ( (||A||**2 + 1 )*||X|| + SCALE * ||Y|| )     (1)
!>
!> The norms are evaluated in terms of the Frobenius norm.
!>

🫶 Remarks 🫶

Auxiliary memory is managed by the function itself. Self-sufficient, as she should be.

✨ Parameters ✨

TRANS

CHARACTER(1) — specifies the form of the system of equations with respect to A:
- 'N': op(A) = A (no transpose for A)
- 'T': op(A) = A**T (transpose A)

M

INTEGER — the order of the matrix A. M >= 0.

A

DOUBLE PRECISION array, dimension (LDA,M) — the coefficient matrix A.

LDA

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

X

DOUBLE PRECISION array, dimension (LDX,M) — the solution of the Stein Equation.

LDX

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

Y

DOUBLE PRECISION array, dimension (LDY,M) — the right hand side of the Stein Equation.

LDY

INTEGER — the leading dimension of the array Y. LDY >= max(1,M).

SCALE

DOUBLE PRECISION — a scaling factor to prevent the overflow in the result.

✨ Returns ✨

The function returns the relative residual as defined in (1). If an error occurs a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value. If I = -1000, the auxiliary memory could not be allocated.

!> .fi

👑 Author 👑

Martin Koehler, MPI Magdeburg

🎀 Date 🎀

October 2025

🦋 Definition 🦋

At line 116 of file res_stein.f90.

double precision function dla_residual_sylv (character transa, character
    transb, double precision sgn, integer m, integer n, double precision,
    dimension(lda, *) a, integer lda, double precision, dimension(ldb, *) b,
    integer ldb, double precision, dimension(ldx, *) x, integer ldx, double
    precision, dimension(ldy, *) y, integer ldy, double precision scale)

Compute the relative residual for the Sylvester equation. THE one, THE only, THE Sylvester 🔥

🌸 Purpose 🌸

!>
!> Compute the relative residual of the Sylvester equation
!>
!>     RelRes = || SCALE*Y - opA(A)*X - SGN * X * opB(B) || / ( (||A||+||B||)*||X|| + SCALE * ||Y|| )     (1)
!>
!> The norms are evaluated in terms of the Frobenius norm.
!>

🫶 Remarks 🫶

Auxiliary memory is managed by the function itself.

✨ Parameters ✨

TRANSA

CHARACTER(1) — specifies the form of the system of equations with respect to A:
- 'N': opA(A) = A (no transpose for A)
- 'T': opA(A) = A**T (transpose A)

TRANSB

CHARACTER(1) — specifies the form of the system of equations with respect to B:
- 'N': opB(B) = B (no transpose for B)
- 'T': opB(B) = B**T (transpose B)

SGN

DOUBLE PRECISION, allowed values: +/-1 — specifies the sign between the two parts of the Sylvester equation. Pick a lane bestie, plus or minus, no in-between 💅

M

INTEGER — the order of the matrix A. M >= 0.

N

INTEGER — the order of the matrix B. N >= 0.

A

DOUBLE PRECISION array, dimension (LDA,M) — the coefficient matrix A.

LDA

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

B

DOUBLE PRECISION array, dimension (LDB,N) — the coefficient matrix B.

LDB

INTEGER — "the leading dimension of the array A." LDB >= max(1,N). It said A again. We've made peace with it 🙈

X

DOUBLE PRECISION array, dimension (LDX,N) — the solution of the Sylvester Equation.

LDX

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

Y

DOUBLE PRECISION array, dimension (LDY,N) — the right hand side of the Sylvester Equation.

LDY

INTEGER — the leading dimension of the array Y. LDY >= max(1,M).

SCALE

DOUBLE PRECISION — a scaling factor to prevent the overflow in the result. She stays protecting the result, periodt ✨

✨ Returns ✨

The function returns the relative residual as defined in (1). If an error occurs a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value. If I = -1000, the auxiliary memory could not be allocated.

!> .fi

👑 Author 👑

Martin Koehler, MPI Magdeburg

🎀 Date 🎀

October 2025

🦋 Definition 🦋

At line 148 of file res_sylv.f90.

💖 `dla_residual_sylv2` 💖

okay bestie, first up we got the double precision girly that checks the relative residual for the discrete-time Sylvester equation. she's giving quality control energy fr fr 💅

double precision function dla_residual_sylv2 (character transa, character
    transb, double precision sgn, integer m, integer n, double precision,
    dimension(lda, *) a, integer lda, double precision, dimension(ldb, *) b,
    integer ldb, double precision, dimension(ldx, *) x, integer ldx, double
    precision, dimension(ldy, *) y, integer ldy, double precision scale)

🎯 Purpose

okay so she computes the relative residual of the discrete-time Sylvester equation:

RelRes = || SCALE*Y - opA(A)*X*opB(B) - SGN * X ) || / ( (||A||*||B||+1)*||X|| + SCALE * ||Y|| )     (1)

and bestie, the norms are evaluated in terms of the Frobenius norm. no cap ✨

📝 Remarks

Auxiliary memory is managed by the function itself. she handles her own business, iconic behavior honestly 🫶

🔧 Parameters

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A :
- == 'N': opA(A) = A (No transpose for A)
- == 'T': opA(A) = A**T (Transpose A)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B :
- == 'N': opB(B) = B (No transpose for B)
- == 'T': opB(B) = B**T (Transpose B)
SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation. she's literally just a lil plus-or-minus queen 💅
M — M is INTEGER. The order of the matrix A. M >= 0.
N — N is INTEGER. The order of the matrix B. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The coefficient matrix A.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — B is DOUBLE PRECISION array, dimension (LDB,N). The coefficient matrix B.
LDB — LDB is INTEGER. The leading dimension of the array A. LDB >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). Solution of the Sylvester Equation.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
Y — Y is DOUBLE PRECISION array, dimension (LDY,N). The right hand side of the Sylvester Equation.
LDY — LDY is INTEGER. The leading dimension of the array Y. LDY >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. keeping things from going feral, we love a stabilizer 🌸

📬 Returns

The function returns the relative residual as defined in (1). If an error occurs a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value. If I = -1000, the auxiliary memory could not be allocated. 😭

✍️ Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

Definition at line 148 of file res_sylv2.f90.

🦋 `sla_residual_csylv` 🦋

next up: the real (single precision, not the ✨romantic✨ kind) version for the coupled Sylvester equation. she's got TWO equations to babysit and she's thriving 🔥

real function sla_residual_csylv (character transa, character transb, real
    sgn1, real sgn2, integer m, integer n, real, dimension(lda, *) a,
    integer lda, real, dimension(ldb, *) b, integer ldb, real,
    dimension(ldc,*) c, integer ldc, real, dimension(ldd, *) d, integer ldd,
    real, dimension(ldr, *) r, integer ldr, real, dimension(ldl, *) l,
    integer ldl, real, dimension(lde, *) e, integer lde, real,
    dimension(ldf, *) f, integer ldf, real scale)

🎯 Purpose

she computes the relative residual of the coupled Sylvester equation:

RelRes = max( || SCALE*E - opA(A)*R - SGN1 * L *opB(B) || / ( (||A||*||R||+||B||*||L||) + SCALE * ||E|| ),
              || SCALE*F - opA(C)*R - SGN2 * L *opB(D) || / ( (||C||*||R||+||D||*||L||) + SCALE * ||F|| ))    (1)

and again bestie, the norms are evaluated in terms of the Frobenius norm. periodt 💜

📝 Remarks

Auxiliary memory is managed by the function itself. self-sufficient queen 🫶

🔧 Parameters

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A :
- == 'N': opA(A) = A (No transpose for A)
- == 'T': opA(A) = A**T (Transpose A)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B :
- == 'N': opB(B) = B (No transpose for B)
- == 'T': opB(B) = B**T (Transpose B)
SGN1 — SGN1 is REAL, allowed values: +/-1. Specifies the sign between the two parts of the first equation.
SGN2 — SGN2 is REAL, allowed values: +/-1. Specifies the sign between the two parts of the second equation. two signs, two vibes, we stay organized ✨
M — M is INTEGER. The order of the matrix A. M >= 0.
N — N is INTEGER. The order of the matrix B. N >= 0.
A — A is REAL array, dimension (LDA,M). The coefficient matrix A.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — B is REAL array, dimension (LDB,N). The coefficient matrix B.
LDB — LDB is INTEGER. The leading dimension of the array A. LDB >= max(1,N).
C — C is REAL array, dimension (LDC,M). The coefficient matrix C.
LDC — LDC is INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — D is REAL array, dimension (LDD,N). The coefficient matrix D.
LDD — LDD is INTEGER. The leading dimension of the array A. LDD >= max(1,N).
R — R is REAL array, dimension (LDR,N). First part of the solution of the Sylvester Equation.
LDR — LDR is INTEGER. The leading dimension of the array R. LDR >= max(1,M).
L — L is REAL array, dimension (LDL,N). Second part of the solution of the Sylvester Equation.
LDL — LDL is INTEGER. The leading dimension of the array L. LDL >= max(1,M).
E — E is REAL array, dimension (LDE,N). The first right hand side of the Sylvester Equation.
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is REAL array, dimension (LDF,N). The second right hand side of the Sylvester Equation.
LDF — LDF is INTEGER. The leading dimension of the array F. LDF >= max(1,M).
SCALE — SCALE is REAL. SCALE is a scaling factor to prevent the overflow in the result. again, the anti-overflow bodyguard, we stan 🎀

📬 Returns

✍️ Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

Definition at line 204 of file res_csylv.f90.

🌈 `sla_residual_csylv_dual` 🌈

and now the dual version of the coupled Sylvester residual, still in REAL. she's the twin sister, same energy, different equations 💅

real function sla_residual_csylv_dual (character transa, character transb,
    real sgn1, real sgn2, integer m, integer n, real, dimension(lda, *) a,
    integer lda, real, dimension(ldb, *) b, integer ldb, real,
    dimension(ldc,*) c, integer ldc, real, dimension(ldd, *) d, integer ldd,
    real, dimension(ldr, *) r, integer ldr, real, dimension(ldl, *) l,
    integer ldl, real, dimension(lde, *) e, integer lde, real,
    dimension(ldf, *) f, integer ldf, real scale)

🎯 Purpose

she computes the relative residual of the dual coupled Sylvester equation:

RelRes = max( || SCALE*E - opA(A)**T *R - opA(C) ** T *L || / ( (||A||*||R||+||C||*||L||) + SCALE * ||E|| ),
              || SCALE*F - SGN1 * R  * opB(B)**T - SGN2 * L * opB(D) **T || / ( (||B||*||R||+||D||*||L||) + SCALE * ||F||)) (1)

and yep, the norms are evaluated in terms of the Frobenius norm. ✨

📝 Remarks

Auxiliary memory is managed by the function itself. independent icon behavior 🫶

🔧 Parameters

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A :
- == 'N': opA(A) = A (No transpose for A)
- == 'T': opA(A) = A**T (Transpose A)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B :
- == 'N': opB(B) = B (No transpose for B)
- == 'T': opB(B) = B**T (Transpose B)
SGN1 — SGN1 is REAL, allowed values: +/-1. Specifies the sign between the two parts of the first equation.
SGN2 — SGN2 is REAL, allowed values: +/-1. Specifies the sign between the two parts of the second equation.
M — M is INTEGER. The order of the matrix A. M >= 0.
N — N is INTEGER. The order of the matrix B. N >= 0.
A — A is REAL array, dimension (LDA,M). The coefficient matrix A.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — B is REAL array, dimension (LDB,N). The coefficient matrix B.
LDB —
LDB — LDB is INTEGER, bestie. It's the leading dimension of the array A (yes, the docs rly say A here, we're just the messenger 💀). Rule: LDB >= max(1,N).
C — C is REAL array, dimension (LDC,M) — the coefficient matrix C. ✨
LDC — LDC is INTEGER — the leading dimension of the array C. You need LDC >= max(1,M).
D — D is REAL array, dimension (LDD,N) — the coefficient matrix D. 💅
LDD — LDD is INTEGER — the leading dimension of the array A (again, the manpage says A, we are simply not going to argue with the manpage 🙈). Constraint: LDD >= max(1,N).
R — R is REAL array, dimension (LDR,N) — the first part of the solution of the Sylvester Equation. First half of the glow-up 💖
LDR — LDR is INTEGER — the leading dimension of the array R. Needs LDR >= max(1,M).
L — L is REAL array, dimension (LDL,N) — the second part of the solution of the Sylvester Equation. The other half, we love a duo 🫶
LDL — LDL is INTEGER — the leading dimension of the array L. Needs LDL >= max(1,M).
E — E is REAL array, dimension (LDE,N) — the first right hand side of the Sylvester Equation. ✨
LDE — LDE is INTEGER — the leading dimension of the array E. Needs LDE >= max(1,M).
F — F is REAL array, dimension (LDF,N) — the second right hand side of the Sylvester Equation. ✨
LDF — LDF is INTEGER — the leading dimension of the array F. Needs LDF >= max(1,M).
SCALE — SCALE is REAL — SCALE is a scaling factor to prevent the overflow in the result. She's literally there so your numbers don't explode 🔥

Returns

ok so here's the tea 🎀 The function returns the relative residual as defined in (1). If an error occurs a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value. If I = -1000, the auxiliary memory could not be allocated. 😭

Translation for the besties: negative I = something is wrong, and -I tells you which parameter is sus. And if you get I = -1000, the allocator ghosted you and there was no memory. Not your math's fault, bestie.

Author

Martin Koehler, MPI Magdeburg 👑

Date

October 2025 🌸

Definition at line 204 of file res_csylv_dual.f90.

`sla_residual_glyap` 🌈

real function sla_residual_glyap (character trans, integer m, 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 scale)

Compute the relative residual for the generalized Lyapunov equation. Yesss generalized, we're leveling up 💅

Purpose

!>
!> Compute the relative residual of the Lyapunov equation
!>
!>     RelRes = || SCALE*Y - op(A)*X*op(B)**T - op(B) * X * op(A)**T || / ( 2*||A||*||B||*||X|| + SCALE * ||Y|| )     (1)
!>
!> The norms are evaluated in terms of the Frobenius norm.
!>

Frobenius norm, no cap — that's the one being used here, so don't come at her with a different norm and expect the same numbers 🙈

Remarks

Auxiliary memory is managed by the function itself. She handles her own business, we love a self-sufficient queen 👑

Parameters

TRANS — TRANS is CHARACTER(1). Specifies the form of the system of equations with respect to A:
- == 'N': op(A) = A (No transpose for A)
- == 'T': op(A) = A**T (Transpose A)
M — M is INTEGER — the order of the matrix A. Constraint: M >= 0.
A — A is REAL array, dimension (LDA,M) — the coefficient matrix A. ✨
LDA — LDA is INTEGER — the leading dimension of the array A. Needs LDA >= max(1,M).
B — B is REAL array, dimension (LDB,M) — the coefficient matrix B. ✨
LDB — LDB is INTEGER — the leading dimension of the array B. Needs LDB >= max(1,M).
X — X is REAL array, dimension (LDX,M) — solution of the Lyapunov Equation. The main character of this whole operation 💖
LDX — LDX is INTEGER — the leading dimension of the array X. Needs LDX >= max(1,M).
Y — Y is REAL array, dimension (LDY,M) — the right hand side of the Lyapunov Equation. ✨
LDY — LDY is INTEGER — the leading dimension of the array Y. Needs LDY >= max(1,M).
SCALE — SCALE is REAL — SCALE is a scaling factor to prevent the overflow in the result. 🛟

Returns

The function returns the relative residual as defined in (1). If an error occurs a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value. If I = -1000, the auxiliary memory could not be allocated. Same deal as before, bestie — negative I = bad param, -1000 = memory said no 😭

Author

Martin Koehler, MPI Magdeburg 👑

Date

October 2025 🌸

Definition at line 129 of file res_glyap.f90.

`sla_residual_gstein` 🦋

real function sla_residual_gstein (character trans, integer m, 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 scale)

Compute the relative residual for the generalized Stein equation. Stein equation girlies rise up 🎀

Purpose

!>
!> Compute the relative residual of the Stein equation
!>
!>     RelRes = || SCALE*Y - op(A)*X*op(A)**T + op(B) * X * op(B)**T || / ( (||A||**2+||B||**2)*||X|| + SCALE * ||Y|| )     (1)
!>
!> The norms are evaluated in terms of the Frobenius norm.
!>

Notice the + in there, not a minus — it's giving Stein, not Lyapunov, and the denominator is (||A||**2+||B||**2)*||X|| because squares are her whole brand ✨

Remarks

Auxiliary memory is managed by the function itself. 💅

Parameters

TRANS — TRANS is CHARACTER(1). Specifies the form of the system of equations with respect to A:
- == 'N': op(A) = A (No transpose for A)
- == 'T': op(A) = A**T (Transpose A)
M — M is INTEGER — the order of the matrix A. Constraint: M >= 0.
A — A is REAL array, dimension (LDA,M) — the coefficient matrix A. ✨
LDA — LDA is INTEGER — the leading dimension of the array A. Needs LDA >= max(1,M).
B — B is REAL array, dimension (LDB,M) — the coefficient matrix B. ✨
LDB — LDB is INTEGER — the leading dimension of the array B. Needs LDB >= max(1,M).
X — X is REAL array, dimension (LDX,M) — solution of the Stein Equation. 👑
LDX — LDX is INTEGER — the leading dimension of the array X. Needs LDX >= max(1,M).
Y — Y is REAL array, dimension (LDY,M) — the right hand side of the Stein Equation. ✨
LDY — LDY is INTEGER — the leading dimension of the array Y. Needs LDY >= max(1,M).
SCALE — SCALE is REAL — SCALE is a scaling factor to prevent the overflow in the result. 🛟

Returns

The function returns the relative residual as defined in (1). If an error occurs a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value. If I = -1000, the auxiliary memory could not be allocated. Yeah, same error protocol, she keeps it consistent 💀

Author

Martin Koehler, MPI Magdeburg 👑

Date

October 2025 🌸

Definition at line 129 of file res_gstein.f90.

`sla_residual_gsylv` 🌈💖

real function sla_residual_gsylv (character transa, character transb, real
    sgn, integer m, integer n, real, dimension(lda, *) a, integer lda, real,
    dimension(ldb, *) b, integer ldb, real, dimension(ldc,*) c, integer ldc,
    real, dimension(ldd, *) d, integer ldd, real, dimension(ldx, *) x,
    integer ldx, real, dimension(ldy, *) y, integer ldy, real scale)

Compute the relative residual for the generalized Sylvester equation. FOUR coefficient matrices, two transposes, one sign — she's doing the absolute most and honestly? Slay. 👑

Purpose

!>
!> Compute the relative residual of the generalized Sylvester equation
!>
!>  RelRes = || SCALE*Y - opA(A)*X*opB(B) - SGN * opA(C) * X opB(D) ) || / ( (||A||*||B||+||C||*||D||)*||X|| + SCALE * ||Y|| )  (1)
!>
!> The norms are evaluated in terms of the Frobenius norm.
!>

Copy that formula exactly, bestie — she wrote it, she owns it, and every paren in there is load-bearing 🙈

Remarks

Auxiliary memory is managed by the function itself. Self-sufficient, as always 💅

Parameters

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A:
- == 'N': opA(A) = A (No transpose for A)
- == 'T': opA(A) = A**T (Transpose A)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B:
- == 'N': opB(B) = B (No transpose for B)
- == 'T': opB(B) = B**T (Transpose B)
SGN — SGN is REAL, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation. It's the vibe check on whether the two halves add or subtract, and it only accepts +/-1 — no freelancing 🔥
M — M is INTEGER — the order of the matrix A. Constraint: M >= 0.
N — N is INTEGER — the order of the matrix B. Constraint: N >= 0.
A — A is REAL array, dimension (LDA,M) — the coefficient matrix A. ✨
LDA — LDA is INTEGER — the leading dimension of the array A. Needs LDA >= max(1,M).
B — B is REAL array, dimension (LDB,N) — the coefficient matrix B. ✨
LDB — LDB is INTEGER — the leading dimension of the array A (yes, A again — the manpage is committed to this bit 💀). Needs LDB >= max(1,N).
C — C is REAL array, dimension (LDC,M) — the coefficient matrix C. ✨
LDC — LDC is INTEGER — the leading dimension of the array C. Needs LDC >= max(1,M).
D — D is REAL array, dimension (LDD,N) — the coefficient matrix D. ✨
LDD — LDD is INTEGER — the leading dimension of the array A (third time's the charm 🙈). Needs LDD >= max(1,N).
X — X is REAL array, dimension (LDX,N) — solution of the Sylvester Equation. 💖
LDX — LDX is INTEGER — the leading dimension of the array X. Needs LDX >= max(1,M).
Y —
Y — Y is a REAL array, dimension (LDY,N) 💖 it's literally the right hand side of the Sylvester Equation, bestie, no notes. 🫶
LDY — LDY is INTEGER. It's the leading dimension of the array Y, and the vibe check here is strict: LDY >= max(1,M). 💅
SCALE — SCALE is REAL. It's the scaling factor that stops your result from overflowing — like the little seatbelt keeping everything cute and contained. 🎀

✨ Returns ✨

The function hands you back the relative residual as defined in (1). But if an error happens, a negative integer I comes back instead, signalizing that the parameter -I has a wrong/illegal value 😭 and if I = -1000, bestie, the auxiliary memory could not be allocated. tragic.

.fi

✨ Author ✨

Martin Koehler, MPI Magdeburg 👑

✨ Date ✨

October 2025 🗓️

Definition at line 172 of file res_gsylv.f90.

🌸 `sla_residual_lyap` 🌸

real function sla_residual_lyap (character trans, integer m, real,
    dimension(lda, *) a, integer lda, real, dimension(ldx, *) x, integer
    ldx, real, dimension(ldy, *) y, integer ldy, real scale)

Compute the relative residual for the Lyapunov equation. that's the whole assignment, and she ate. ✨

🦋 Purpose

Compute the relative residual of the Lyapunov equation

RelRes = || SCALE*Y - op(A)*X - X * op(A)**T || / ( 2*||A||*||X|| + SCALE * ||Y|| )     (1)

The norms are evaluated in terms of the Frobenius norm. no cap. 🧚

🎀 Remarks

Auxiliary memory is managed by the function itself — she handles her own business, you don't have to. 💅

💖 Parameters

TRANS — TRANS is CHARACTER(1). It specifies the form of the system of equations with respect to A:
- == 'N': op(A) = A (No transpose for A)
- == 'T': op(A) = A**T (Transpose A)
M — M is INTEGER. The order of the matrix A. M >= 0. 📏
A — A is a REAL array, dimension (LDA,M). It's the coefficient matrix A, the main character of this equation. 👑
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M). 🫶
X — X is a REAL array, dimension (LDX,M). Solution of the Lyapunov Equation. the moment. ✨
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M). 💅
Y — Y is a REAL array, dimension (LDY,M). The right hand side of the Lyapunov Equation. 🫶
LDY — LDY is INTEGER. The leading dimension of the array Y. LDY >= max(1,M). 🎀
SCALE — SCALE is REAL. A scaling factor to prevent the overflow in the result. keeping it contained, keeping it cute. 🌸

✨ Returns ✨

The function returns the relative residual as defined in (1). If an error occurs a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value 😭 and if I = -1000, the auxiliary memory could not be allocated. not the allocated-memory L. 💀

.fi

✨ Author ✨

Martin Koehler, MPI Magdeburg 👑

✨ Date ✨

October 2025 🗓️

Definition at line 116 of file res_lyap.f90.

🌈 `sla_residual_stein` 🌈

real function sla_residual_stein (character trans, integer m, real,
    dimension(lda, *) a, integer lda, real, dimension(ldx, *) x, integer
    ldx, real, dimension(ldy, *) y, integer ldy, real scale)

Compute the relative residual for the Stein equation. periodt. 💅

🦋 Purpose

Compute the relative residual of the Stein equation

RelRes = || SCALE*Y - op(A)*X*op(A)**T + X || / ( (||A||**2 + 1 )*||X|| + SCALE * ||Y|| )     (1)

The norms are evaluated in terms of the Frobenius norm. fr fr. 🧚

🎀 Remarks

Auxiliary memory is managed by the function itself — self-sufficient queen behavior. 👑

💖 Parameters

TRANS — TRANS is CHARACTER(1). It specifies the form of the system of equations with respect to A:
- == 'N': op(A) = A (No transpose for A)
- == 'T': op(A) = A**T (Transpose A)
M — M is INTEGER. The order of the matrix A. M >= 0. 📏
A — A is a REAL array, dimension (LDA,M). It's the coefficient matrix A. 👑
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M). 🫶
X — X is a REAL array, dimension (LDX,M). Solution of the Stein Equation. iconic. ✨
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M). 💅
Y — Y is a REAL array, dimension (LDY,M). The right hand side of the Stein Equation. 🫶
LDY — LDY is INTEGER. The leading dimension of the array Y. LDY >= max(1,M). 🎀
SCALE — SCALE is REAL. A scaling factor to prevent the overflow in the result. your lil safety net. 🌸

✨ Returns ✨

The function returns the relative residual as defined in (1). If an error occurs a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value 😭 and if I = -1000, the auxiliary memory could not be allocated. 💀

.fi

✨ Author ✨

Martin Koehler, MPI Magdeburg 👑

✨ Date ✨

October 2025 🗓️

Definition at line 116 of file res_stein.f90.

🦋 `sla_residual_sylv` 🦋

real function sla_residual_sylv (character transa, character transb, 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 scale)

Compute the relative residual for the Sylvester equation. the way she just does that. 💅

🦋 Purpose

Compute the relative residual of the Sylvester equation

RelRes = || SCALE*Y - opA(A)*X - SGN * X * opB(B) || / ( (||A||+||B||)*||X|| + SCALE * ||Y|| )     (1)

The norms are evaluated in terms of the Frobenius norm. 🧚

🎀 Remarks

Auxiliary memory is managed by the function itself. 💖

💖 Parameters

TRANSA — TRANSA is CHARACTER(1). It specifies the form of the system of equations with respect to A:
- == 'N': opA(A) = A (No transpose for A)
- == 'T': opA(A) = A**T (Transpose A)
TRANSB — TRANSB is CHARACTER(1). It specifies the form of the system of equations with respect to B:
- == 'N': opB(B) = B (No transpose for B)
- == 'T': opB(B) = B**T (Transpose B)
SGN — SGN is REAL, allowed values: +/-1. It specifies the sign between the two parts of the Sylvester equation. 🎀
M — M is INTEGER. The order of the matrix A. M >= 0. 📏
N — N is INTEGER. The order of the matrix B. N >= 0. 📐
A — A is a REAL array, dimension (LDA,M). It's the coefficient matrix A. 👑
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M). 🫶
B — B is a REAL array, dimension (LDB,N). It's the coefficient matrix B. 👑
LDB — LDB is INTEGER. The leading dimension of the array A. LDB >= max(1,N). 💅
X — X is a REAL array, dimension (LDX,N). Solution of the Sylvester Equation. ✨
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M). 🎀
Y — Y is a REAL array, dimension (LDY,N). The right hand side of the Sylvester Equation. 🫶
LDY — LDY is INTEGER. The leading dimension of the array Y. LDY >= max(1,M). 🌸
SCALE — SCALE is REAL. A scaling factor to prevent the overflow in the result. 💖

✨ Returns ✨

The function returns the relative residual as defined in (1). If an error occurs a negative integer I is returned, signalizing that the parameter -I has a wrong/illegal value 😭 and if I = -1000, the auxiliary memory could not be allocated. 💀

.fi

✨ Author ✨

Martin Koehler, MPI Magdeburg 👑

✨ Date ✨

October 2025 🗓️

Definition at line 148 of file res_sylv.f90.

🌈 `sla_residual_sylv2` 🌈

real function sla_residual_sylv2 (character transa, character transb, 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 scale)

Compute the relative residual for the discrete-time Sylvester equation. she's the sequel and she understood the assignment. 👑

🦋 Purpose

Compute the relative residual of the discrete-time Sylvester equation

RelRes = || SCALE*Y - opA(A)*X*opB(B) - SGN * X ) || / ( (||A||*||B||+1)*||X|| + SCALE * ||Y|| )     (1)

The norms are evaluated in terms of the Frobenius norm. 🧚

🎀 Remarks

Auxiliary memory is managed by the function itself. 💅

💖 Parameters

TRANSA — TRANSA is CHARACTER(1). It specifies the form of the system of equations with respect to A:
- == 'N': opA(A) = A (No transpose for A)
- == 'T': opA(A) = A**T (Transpose A)
TRANSB — TRANSB is CHARACTER(1). It specifies the form of the system of equations with respect to B:
- == 'N': opB(B) = B (No transpose for B)
- == 'T': opB(B) = B**T (Transpose B)
SGN — SGN is REAL, allowed values: +/-1. It specifies the sign between the two parts of the Sylvester equation. 🎀
M — M is INTEGER. The order of the matrix A. M >= 0. 📏
N — N is INTEGER. The order of the matrix B. N >= 0. 📐
A — A is a REAL array, dimension (LDA,M). It's the coefficient matrix A. 👑
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M). 🫶
B

`B`

B is a REAL array, dimension (LDB,N).
It's the coefficient matrix B. 💖

`LDB`

LDB is an INTEGER.
It's the leading dimension of the array A. And yes bestie, the original really does say A here, we're just reporting the lore: LDB >= max(1,N). 👑

`X`

X is a REAL array, dimension (LDX,N).
It's the solution of the Sylvester Equation. The whole point of the mission, honestly. ✨

`LDX`

LDX is an INTEGER.
Leading dimension of the array X. Rule of the land: LDX >= max(1,M).

`Y`

Y is a REAL array, dimension (LDY,N).
It's the right hand side of the Sylvester Equation. The lil' input that gets fed in. 🍓

`LDY`

LDY is an INTEGER.
Leading dimension of the array Y. And: LDY >= max(1,M).

`SCALE`

SCALE is a REAL.
It's a scaling factor whose entire job is to stop the result from overflowing. Not all heroes wear capes, some just multiply things down so your numbers don't explode. 💅

Returns 🌈

The function returns the relative residual as defined in (1). That's the whole vibe. If something goes wrong, a negative integer I comes back instead — which is the function's way of saying "the parameter -I has a wrong/illegal value," i.e. it's pointing at whichever argument you fumbled.

And one special case, so pay attention: if I = -1000, it means the auxiliary memory could not be allocated. Not your args, not your math — just no room at the inn. 😭

Author 👑

Martin Koehler, MPI Magdeburg

Date 📅

October 2025

Definition at line 148 of file res_sylv2.f90.

Author (the robot one) 🤖

Generated automatically by Doxygen for MEPACK from the source code. It did not write this, it just birthed the raw material. Slay, Doxygen.

And that's a wrap, bestie! 🎀 This page is Version 1.1.2, dated Thu Oct 9 2025 00:00:00, and yes, it's the residual(3) page you've been reading this whole time. Go forth and compute your residuals responsibly. No cap. 💖✨

📦 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

residual(3)

🌸 NAME 🌸

✨ SYNOPSIS ✨

🎀 Topics 🎀

🦋 C-Interface 🦋

🌈 Functions 🌈

🌺 Detailed Description 🌺

👑 Function Documentation 👑

💖 double precision function dla_residual_csylv 💖

⭐ Purpose:

🫶 Remarks

🎀 Parameters

🌟 Returns

🧚 Author

🎀 Date

💖 double precision function dla_residual_csylv_dual 💖

⭐ Purpose:

🫶 Remarks

🎀 Parameters

Returns

Author

Date

💖 dla_residual_glyap 💖

Purpose

Remarks

Parameters

Returns

Author

Date

🦋 dla_residual_gstein 🦋

Purpose

Remarks

Parameters

Returns

Author

Date

✨ dla_residual_gsylv ✨

Purpose

Remarks

Parameters

✨ Returns ✨

👑 Author 👑

🎀 Date 🎀

🦋 Definition 🦋

💜 And now… the rest of the double precision functions 💜

🌸 Purpose 🌸

🫶 Remarks 🫶

✨ Parameters ✨

✨ Returns ✨

👑 Author 👑

🎀 Date 🎀

🦋 Definition 🦋

🌸 Purpose 🌸

🫶 Remarks 🫶

✨ Parameters ✨

✨ Returns ✨

👑 Author 👑

🎀 Date 🎀

🦋 Definition 🦋

🌸 Purpose 🌸

🫶 Remarks 🫶

✨ Parameters ✨

✨ Returns ✨

👑 Author 👑

🎀 Date 🎀

🦋 Definition 🦋

💖 dla_residual_sylv2 💖

🎯 Purpose

📝 Remarks

🔧 Parameters

📬 Returns

✍️ Author

📅 Date

🦋 sla_residual_csylv 🦋

🎯 Purpose

📝 Remarks

🔧 Parameters

📬 Returns

✍️ Author

📅 Date

💖 `dla_residual_glyap` 💖

🦋 `dla_residual_gstein` 🦋

✨ `dla_residual_gsylv` ✨

💖 `dla_residual_sylv2` 💖

🦋 `sla_residual_csylv` 🦋

🌈 `sla_residual_csylv_dual` 🌈

`sla_residual_glyap` 🌈

`sla_residual_gstein` 🦋

`sla_residual_gsylv` 🌈💖

🌸 `sla_residual_lyap` 🌸

🌈 `sla_residual_stein` 🌈

🦋 `sla_residual_sylv` 🦋

🌈 `sla_residual_sylv2` 🌈

`B`

`LDB`

`X`

`LDX`

`Y`

`LDY`

`SCALE`