cresidual(3)

📦

version 1.1.2 · 3 versions

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

🌸 cresidual — C-Interface 💅

okay bestie, come SIT. this is cresidual(3), part of the MEPACK manual, and it's the C-Interface page for residual computations. yes, residuals. the "did my solver actually do the thing" check. main character energy fr fr 🫶

✨ NAME ✨

cresidual — C-Interface

C-Interface for the residual computations.

✨ SYNOPSIS ✨

🎀 Functions 🎀

okay so here's the whole roster, and every single one of these is a real signature, character for character, no notes:

double mepack_double_residual_csylv (const char *TRANSA, const char *TRANSB, double sgn1, double sgn2, int M, int N, double *A, int LDA, double *B, int LDB, double *C, int LDC, double *D, int LDD, double *R, int LDR, double *L, int LDL, double *E, int LDE, double *F, int LDF, double SCALE)

Compute the relative residual for the coupled Sylvester equation.

float mepack_single_residual_csylv (const char *TRANSA, const char *TRANSB, float sgn1, float sgn2, int M, int N, float *A, int LDA, float *B, int LDB, float *C, int LDC, float *D, int LDD, float *R, int LDR, float *L, int LDL, float *E, int LDE, float *F, int LDF, float SCALE)

Compute the relative residual for the coupled Sylvester equation.

double mepack_double_residual_csylv_dual (const char *TRANSA, const char *TRANSB, double sgn1, double sgn2, int M, int N, double *A, int LDA, double *B, int LDB, double *C, int LDC, double *D, int LDD, double *R, int LDR, double *L, int LDL, double *E, int LDE, double *F, int LDF, double SCALE)

Compute the relative residual for the coupled Sylvester equation.

float mepack_single_residual_csylv_dual (const char *TRANSA, const char *TRANSB, float sgn1, float sgn2, int M, int N, float *A, int LDA, float *B, int LDB, float *C, int LDC, float *D, int LDD, float *R, int LDR, float *L, int LDL, float *E, int LDE, float *F, int LDF, float SCALE)

Compute the relative residual for the coupled Sylvester equation.

double mepack_double_residual_glyap (const char *TRANS, int M, double *A, int LDA, double *B, int LDB, double *X, int LDX, double *Y, int LDY, double SCALE)

Compute the relative residual for the generalized Lyapunov equation.

float mepack_single_residual_glyap (const char *TRANS, int M, float *A, int LDA, float *B, int LDB, float *X, int LDX, float *Y, int LDY, float SCALE)

Compute the relative residual for the generalized Lyapunov equation.

double mepack_double_residual_gstein (const char *TRANS, int M, double *A, int LDA, double *B, int LDB, double *X, int LDX, double *Y, int LDY, double SCALE)

Compute the relative residual for the generalized Stein equation.

float mepack_single_residual_gstein (const char *TRANS, int M, float *A, int LDA, float *B, int LDB, float *X, int LDX, float *Y, int LDY, float SCALE)

Compute the relative residual for the generalized Stein equation.

double mepack_double_residual_gsylv (const char *TRANSA, const char *TRANSB, double sgn, int M, int N, double *A, int LDA, double *B, int LDB, double *C, int LDC, double *D, int LDD, double *X, int LDX, double *Y, int LDY, double SCALE)

Compute the relative residual for the generalized Sylvester equation.

float mepack_single_residual_gsylv (const char *TRANSA, const char *TRANSB, float sgn, int M, int N, float *A, int LDA, float *B, int LDB, float *C, int LDC, float *D, int LDD, float *X, int LDX, float *Y, int LDY, float SCALE)

Compute the relative residual for the generalized Sylvester equation.

double mepack_double_residual_lyap (const char *TRANS, int M, double *A, int LDA, double *X, int LDX, double *Y, int LDY, double SCALE)

Compute the relative residual for the Lyapunov equation.

float mepack_single_residual_lyap (const char *TRANS, int M, float *A, int LDA, float *X, int LDX, float *Y, int LDY, float SCALE)

Compute the relative residual for the Lyapunov equation.

double mepack_double_residual_stein (const char *TRANS, int M, double *A, int LDA, double *X, int LDX, double *Y, int LDY, double SCALE)

Compute the relative residual for the Stein equation.

float mepack_single_residual_stein (const char *TRANS, int M, float *A, int LDA, float *X, int LDX, float *Y, int LDY, float SCALE)

Compute the relative residual for the Stein equation.

double mepack_double_residual_sylv (const char *TRANSA, const char *TRANSB, double sgn, int M, int N, double *A, int LDA, double *B, int LDB, double *X, int LDX, double *Y, int LDY, double SCALE)

Compute the relative residual for the Sylvester equation.

float mepack_single_residual_sylv (const char *TRANSA, const char *TRANSB, float sgn, int M, int N, float *A, int LDA, float *B, int LDB, float *X, int LDX, float *Y, int LDY, float SCALE)

Compute the relative residual for the Sylvester equation.

double mepack_double_residual_sylv2 (const char *TRANSA, const char *TRANSB, double sgn, int M, int N, double *A, int LDA, double *B, int LDB, double *X, int LDX, double *Y, int LDY, double SCALE)

Compute the relative residual for the discrete-time Sylvester equation.

float mepack_single_residual_sylv2 (const char *TRANSA, const char *TRANSB, float sgn, int M, int N, float *A, int LDA, float *B, int LDB, float *X, int LDX, float *Y, int LDY, float SCALE)

Compute the relative residual for the discrete-time Sylvester equation.

🌈 Detailed Description 🌈

C-Interface for the residual computations.

The routines in this group are wrappers around the Fortran routines from Residual Computations. so like, the Fortran girlies did the heavy lifting, and these are the C besties holding the door open 🫶

💖 Function Documentation 💖

⭐ mepack_double_residual_csylv ⭐

double mepack_double_residual_csylv (const char * TRANSA, const char * TRANSB, double sgn1, double sgn2, int M, int N, double * A, int LDA, double * B, int LDB, double * C, int LDC, double * D, int LDD, double * R, int LDR, double * L, int LDL, double * E, int LDE, double * F, int LDF, double 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. so you don't gotta malloc anything, she handles it 💅

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 in the first equation.
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign in 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 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 B. LDB >= max(1,N).
C — 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 — D is DOUBLE PRECISION array, dimension (LDD,N). The coefficient matrix D.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
R — R is DOUBLE PRECISION array, dimension (LDR,N). The first of the Sylvester Equation.
LDR — LDR is INTEGER. The leading dimension of the array R. LDX >= max(1,M).

ngl bestie, that LDX in the LDR description is straight from the source — it says LDX even though we're talking about R here. i'm not fixing it, i'm just reporting it 🙈

L — L is DOUBLE PRECISION array, dimension (LDL,N). The second solution the Sylvester Equation.
LDL — LDL is INTEGER. The leading dimension of the array L. LDL >= max(1,M).
E — 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 — 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. she's the 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. If I = -1000, the auxiliary memory could not be allocated.

See also

dla_residual_csylv

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 201 of file csylv.c.

⭐ mepack_double_residual_csylv_dual ⭐

double mepack_double_residual_csylv_dual (const char * TRANSA, const char * TRANSB, double sgn1, double sgn2, int M, int N, double * A, int LDA, double * B, int LDB, double * C, int LDC, double * D, int LDD, double * R, int LDR, double * L, int LDL, double * E, int LDE, double * F, int LDF, double 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)**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. again, she's got it, you don't 💅

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 — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B, bestie 💖:
- == '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 in the first equation. periodt.
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign in the second equation. no cap.
M — M is INTEGER. The order of the matrix A. M >= 0. gotta be non-negative, fr fr.
N — N is INTEGER. The order of the matrix B. N >= 0. same energy.
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). iconic.
B — B is DOUBLE PRECISION array, dimension (LDB,N). The coefficient matrix B.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — 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 — D is DOUBLE PRECISION array, dimension (LDD,N). The coefficient matrix D.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
R — R is DOUBLE PRECISION array, dimension (LDR,N). The first of the Sylvester Equation.
LDR — LDR is INTEGER. The leading dimension of the array R. LDX >= max(1,M). (yes bestie, it says LDX here, not LDR — we don’t make the rules 💀)
L — L is DOUBLE PRECISION array, dimension (LDL,N). The second solution the Sylvester Equation.
LDL — LDL is INTEGER. The leading dimension of the array L. LDL >= max(1,M).
E — 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 — 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. she’s just here to keep things from going feral 🔥.

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. so if you see a negative number, something’s sus 👀.

Author ✍️

Martin Koehler, MPI Magdeburg

Date 📅

October 2025

Definition 📍

Definition at line 201 of file csylv_dual.c.

✨ `mepack_double_residual_glyap` ✨

double mepack_double_residual_glyap (const char * TRANS, int M, double * A,
    int LDA, double * B, int LDB, double * X, int LDX, double * Y, int LDY,
    double SCALE)

Compute the relative residual for the generalized Lyapunov equation.

Purpose 🎯

Compute the relative residual of the generalized 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.

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, bestie:
- == 'N': op(A) = A (No transpose for A)
- == 'T': op(A) = A**T (Transpose A)
M — M is INTEGER. The order of the matrices A. M >= 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,M). The coefficient matrix B.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,M).
X — X is DOUBLE PRECISION array, dimension (LDX,M). Solution of the Lyapunov Equation.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
Y — Y is DOUBLE PRECISION array, dimension (LDX,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 DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result.

Returns 💖

Author ✍️

Martin Koehler, MPI Magdeburg

Date 📅

October 2025

Definition 📍

Definition at line 126 of file glyap.c.

✨ `mepack_double_residual_gstein` ✨

double mepack_double_residual_gstein (const char * TRANS, int M, double * A,
    int LDA, double * B, int LDB, double * X, int LDX, double * Y, int LDY,
    double SCALE)

Compute the relative residual for the generalized Stein equation.

Purpose 🎯

Compute the relative residual of the generalized 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.

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 matrices A. M >= 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,M). The coefficient matrix B.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,M).
X — X is DOUBLE PRECISION array, dimension (LDX,M). Solution of the Stein Equation.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
Y — Y is DOUBLE PRECISION array, dimension (LDX,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 DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result.

Returns 💖

Author ✍️

Martin Koehler, MPI Magdeburg

Date 📅

October 2025

Definition 📍

Definition at line 126 of file gstein.c.

✨ `mepack_double_residual_gsylv` ✨

double mepack_double_residual_gsylv (const char * TRANSA, const char *
    TRANSB, double sgn, int M, int N, double * A, int LDA, double * B, int
    LDB, double * C, int LDC, double * D, int LDD, double * X, int LDX,
    double * Y, int LDY, double SCALE)

Compute the relative residual for the generalized Sylvester equation.

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.

Remarks 📝

Auxiliary memory is managed by the function itself.

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.
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 B. LDB >= max(1,N).
C — 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 — D is DOUBLE PRECISION array, dimension (LDD,N). The coefficient matrix D.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= 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 — bestie, Y is a DOUBLE PRECISION array, dimension (LDY,N). It's 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. ✨

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 170 of file gsylv.c.

💅 `double mepack_double_residual_lyap (const char * TRANS, int M, double * A, int LDA, double * X, int LDX, double * Y, int LDY, double SCALE)`

Compute the relative residual for the Lyapunov equation. 🦋

✨ 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. no cap.

📝 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 matrices A. M >= 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).
X — X is DOUBLE PRECISION array, dimension (LDX,M). Solution of the Lyapunov Equation.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
Y — Y is DOUBLE PRECISION array, dimension (LDX,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 DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result.

🔙 Returns 🔙

👀 See also 👀 dla_residual_lyap

✍️ Author ✍️ Martin Koehler, MPI Magdeburg

📅 Date 📅 October 2025

📍 Definition at line 114 of file lyap.c.

🌟 `double mepack_double_residual_stein (const char * TRANS, int M, double * A, int LDA, double * X, int LDX, double * Y, int LDY, double SCALE)`

Compute the relative residual for the Stein equation. 🎀

✨ 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. no cap.

📝 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 matrices A. M >= 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).
X — X is DOUBLE PRECISION array, dimension (LDX,M). Solution of the Stein Equation.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
Y — Y is DOUBLE PRECISION array, dimension (LDX,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 DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result.

🔙 Returns 🔙

👀 See also 👀 dla_residual_stein

✍️ Author ✍️ Martin Koehler, MPI Magdeburg

📅 Date 📅 October 2025

📍 Definition at line 114 of file stein.c.

🔥 `double mepack_double_residual_sylv (const char * TRANSA, const char * TRANSB, double sgn, int M, int N, double * A, int LDA, double * B, int LDB, double * X, int LDX, double * Y, int LDY, double SCALE)`

Compute the relative residual for the Sylvester equation. 👑

✨ 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. no cap.

📝 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.
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 B. LDB >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,M). 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 (LDX,M). 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.

🔙 Returns 🔙

👀 See also 👀 dla_residual_sylv

✍️ Author ✍️ Martin Koehler, MPI Magdeburg

📅 Date 📅 October 2025

📍 Definition at line 147 of file sylv.c.

🌈 `double mepack_double_residual_sylv2 (const char * TRANSA, const char * TRANSB, double sgn, int M, int N, double * A, int LDA, double * B, int LDB, double * X, int LDX, double * Y, int LDY, double SCALE)`

Compute the relative residual for the discrete-time Sylvester equation. 🦋

✨ Purpose ✨

Compute the relative residual of the discrete-time Sylvester equation

RelRes = || SCALE*Y - opA(A)*X*op(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. no cap.

📝 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.
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 B. LDB >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,M). 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 (LDX,M). 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.

Returns

...and yeah, that's the relative residual, exactly as defined in that (1) up there. 💖

If something goes wrong it hands you back a negative integer I, which is basically the function screaming "bestie, parameter -I is illegal/wrong, fix it." 🙈 And if I = -1000? That means the auxiliary memory could not be allocated. Rude, but at least it's honest. 💀

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition

At line 147 of file sylv2.c.

✨ `float mepack_single_residual_csylv (const char * TRANSA, const char * TRANSB, float sgn1, float sgn2, int M, int N, float * A, int LDA, float * B, int LDB, float * C, int LDC, float * D, int LDD, float * R, int LDR, float * L, int LDL, float * E, int LDE, float * F, int LDF, float SCALE)` ✨

Compute the relative residual for the coupled Sylvester equation. 🦋

Purpose

So like, it computes the relative residual of the coupled Sylvester equation, and it's giving:

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. Periodt. 💅

Remarks

Auxiliary memory is managed by the function itself. It's independent, it handles its own business, main character energy 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)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign in the first equation.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign in 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 SINGLE 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 SINGLE PRECISION array, dimension (LDB,N). The coefficient matrix B.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — C is SINGLE 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 — D is SINGLE PRECISION array, dimension (LDD,N). The coefficient matrix D.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
R — R is SINGLE PRECISION array, dimension (LDR,N). The first of the Sylvester Equation.
LDR — LDR is INTEGER. The leading dimension of the array R. LDX >= max(1,M).
L — L is SINGLE PRECISION array, dimension (LDL,N). The second solution the Sylvester Equation.
LDL — LDL is INTEGER. The leading dimension of the array L. LDL >= max(1,M).
E — E is SINGLE 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 — F is SINGLE 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 SINGLE 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. 😭

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition

At line 397 of file csylv.c.

✨ `float mepack_single_residual_csylv_dual (const char * TRANSA, const char * TRANSB, float sgn1, float sgn2, int M, int N, float * A, int LDA, float * B, int LDB, float * C, int LDC, float * D, int LDD, float * R, int LDR, float * L, int LDL, float * E, int LDE, float * F, int LDF, float SCALE)` ✨

Compute the relative residual for the coupled Sylvester equation. 💜 (yes, the dual one, we're doing it again but transposed-ily, iykyk)

Purpose

Compute the relative residual of the 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.

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 SINGLE PRECISION, allowed values: +/-1. Specifies the sign in the first equation.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign in 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 SINGLE 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 SINGLE PRECISION array, dimension (LDB,N). The coefficient matrix B.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — C is SINGLE 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 — D is SINGLE PRECISION array, dimension (LDD,N). The coefficient matrix D.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
R — R is SINGLE PRECISION array, dimension (LDR,N). The first of the Sylvester Equation.
LDR — LDR is INTEGER. The leading dimension of the array R. LDX >= max(1,M).
L — L is SINGLE PRECISION array, dimension (LDL,N). The second solution the Sylvester Equation.
LDL — LDL is INTEGER. The leading dimension of the array L. LDL >= max(1,M).
E — E is SINGLE 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 — F is SINGLE 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 SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result.

Returns

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition

At line 397 of file csylv_dual.c.

✨ `float mepack_single_residual_glyap (const char * TRANS, int M, float * A, int LDA, float * B, int LDB, float * X, int LDX, float * Y, int LDY, float SCALE)` ✨

Compute the relative residual for the generalized Lyapunov equation. 🌸

Purpose

Compute the relative residual of the generalized 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. ✨

Remarks

Auxiliary memory is managed by the function itself. She's self-sufficient, she's thriving. 🫶

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 matrices A. M >= 0.
A — A is SINGLE 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 SINGLE PRECISION array, dimension (LDB,M). The coefficient matrix B.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,M).
X — X is SINGLE PRECISION array, dimension (LDX,M). Solution of the Lyapunov Equation.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
Y — Y is SINGLE PRECISION array, dimension (LDX,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 — SCALE</p> is SINGLE PRECISION. It's literally a scaling factor that stops the result from overflowing bestie, she's doing the lord's work 💅

Returns

The function hands you back the relative residual like we defined in (1) up there 👆. But if something goes sideways, you get a negative integer I back instead, which is the function's way of being like "bestie, the parameter -I is giving wrong/illegal value energy 😭". And if I = -1000? That means the auxiliary memory could not be allocated. Tragic. No cap. 💀

See also

sla_residual_glyap

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 239 of file glyap.c.

🦋 `mepack_single_residual_gstein`

float mepack_single_residual_gstein (const char * TRANS, int M, float * A,
    int LDA, float * B, int LDB, float * X, int LDX, float * Y, int LDY,
    float SCALE)

Compute the relative residual for the generalized Stein equation. Okay so this one is lowkey iconic, let's get into it 🌸

Purpose:

Compute the relative residual of the generalized 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. Periodt. ✨

Remarks

Auxiliary memory is managed by the function itself. She's independent, she doesn't need you to babysit her memory 🫶

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 matrices A. M >= 0.

A

A is SINGLE 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 SINGLE PRECISION array, dimension (LDB,M). The coefficient matrix B.

LDB

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

X

X is SINGLE PRECISION array, dimension (LDX,M). Solution of the Stein Equation. She's the answer bestie 💖

LDX

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

Y

Y is SINGLE PRECISION array, dimension (LDX,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 SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result.

Returns

See also

sla_residual_gstein

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 239 of file gstein.c.

🎀 `mepack_single_residual_gsylv`

float mepack_single_residual_gsylv (const char * TRANSA, const char *
    TRANSB, float sgn, int M, int N, float * A, int LDA, float * B, int LDB,
    float * C, int LDC, float * D, int LDD, float * X, int LDX, float * Y,
    int LDY, float SCALE)

Compute the relative residual for the generalized Sylvester equation. This one has a LOT of parameters bestie, hydrate first 💧

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. Slay. ✨

Remarks

Auxiliary memory is managed by the function itself.

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 SINGLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation. Pick your fighter: plus or minus 💅

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 SINGLE 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 SINGLE PRECISION array, dimension (LDB,N). The coefficient matrix B.

LDB

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

C

C is SINGLE 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

D is SINGLE PRECISION array, dimension (LDD,N). The coefficient matrix D.

LDD

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

X

X is SINGLE PRECISION array, dimension (LDY,M). Solution of the Sylvester Equation.

LDX

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

Y

Y is SINGLE 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 SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result.

Returns

See also

sla_residual_gsylv

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 331 of file gsylv.c.

🌸 `mepack_single_residual_lyap`

float mepack_single_residual_lyap (const char * TRANS, int M, float * A, int
    LDA, float * X, int LDX, float * Y, int LDY, float SCALE)

Compute the relative residual for the Lyapunov equation. Classic. The main character of matrix equations, honestly 👑

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. Periodt 💜

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 matrices A. M >= 0.

A

A is SINGLE PRECISION array, dimension (LDA,M). The coefficient matrix A.

LDA

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

X

X is SINGLE PRECISION array, dimension (LDX,M). Solution of the Lyapunov Equation.

LDX

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

Y

Y is SINGLE PRECISION array, dimension (LDX,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 SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result.

Returns

See also

sla_residual_lyap

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 213 of file lyap.c.

🦋 `mepack_single_residual_stein`

float mepack_single_residual_stein (const char * TRANS, int M, float * A,
    int LDA, float * X, int LDX, float * Y, int LDY, float SCALE)

Compute the relative residual for the Stein equation. Not to be confused with her generalized sister up there, this is the classic Stein and she's serving ✨

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. Iykyk 💖

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 matrices A. M >= 0.

A

A is SINGLE PRECISION array, dimension (LDA,M). The coefficient matrix A.

LDA

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

X

X is SINGLE PRECISION array, dimension (LDX,M). Solution of the Stein Equation.

LDX

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

Y

Y is SINGLE PRECISION array, dimension (LDX,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 SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result.

Returns

See also

sla_residual_stein

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 213 of file stein.c.

💖 `mepack_single_residual_sylv` 💖

float mepack_single_residual_sylv (const char * TRANSA, const char * TRANSB,
    float sgn, int M, int N, float * A, int LDA, float * B, int LDB, float *
    X, int LDX, float * Y, int LDY, float SCALE)

okay bestie, this one computes the relative residual for the Sylvester equation. yes. we're doing residuals now. slay. ✨

Purpose:

so basically it computes the relative residual of the Sylvester equation

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

and heads up — the norms here are evaluated in terms of the Frobenius norm. that's the whole vibe. 💅

Remarks

the auxiliary memory is managed by the function itself, so you don't have to do a single thing about it 🫶

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.
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 B. LDB >= max(1,N).
X
- X is DOUBLE PRECISION array, dimension (LDX,M)
- 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 (LDX,M)
- 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.

Returns

See also

sla_residual_sylv

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 282 of file sylv.c.

🦋 `mepack_single_residual_sylv2` 🦋

float mepack_single_residual_sylv2 (const char * TRANSA, const char *
    TRANSB, float sgn, int M, int N, float * A, int LDA, float * B, int LDB,
    float * X, int LDX, float * Y, int LDY, float SCALE)

and this one? this one is the discrete-time Sylvester residual. the sequel. the second album. and honestly it ate. 🎀

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)

norms again evaluated in terms of the Frobenius norm, same as before, no surprises. 💜

Remarks

the auxiliary memory is managed by the function itself — it's giving independent. it's giving main character. you literally don't lift a finger. ✨

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 SINGLE PRECISION, allowed values: +/-1
- 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 SINGLE 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 SINGLE PRECISION array, dimension (LDB,N)
- The coefficient matrix B.
LDB
- LDB is INTEGER
- The leading dimension of the array B. LDB >= max(1,N).
X
- X is SINGLE PRECISION array, dimension (LDX,M)
- Solution of the Sylvester Equation.
LDX
- LDX is INTEGER
- The leading dimension of the array X. LDX >= max(1,M).
Y
- Y is SINGLE PRECISION array, dimension (LDX,M)
- 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 SINGLE PRECISION
- SCALE is a scaling factor to prevent the overflow in the result.

Returns

See also

sla_residual_sylv2

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 282 of file sylv2.c.

quick vibe check bestie: these two are literally the same layout of args, but the first one is all DOUBLE PRECISION and the second is all SINGLE PRECISION, and the second is the discrete-time flavor with opA(A)*X*opB(B) in the formula. don't mix them up, i'm begging. 🙈

👑 Author 👑

this page was generated automatically by Doxygen for MEPACK from the source code. yes, a robot wrote the skeleton, and i just gave it a glow-up. periodt. 💅✨

🌈 Version 🌈

you're reading Version 1.1.2, dated Thu Oct 9 2025 00:00:00 — that's the whole cresidual(3) page, start to finish, and yes you read all six parts. iconic behavior honestly. obsessed. go compute some residuals bestie, you've got this 🫶🌸💖

📦 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

cresidual(3)

🌸 cresidual — C-Interface 💅

✨ NAME ✨

✨ SYNOPSIS ✨

🎀 Functions 🎀

🌈 Detailed Description 🌈

💖 Function Documentation 💖

⭐ mepack_double_residual_csylv ⭐

⭐ mepack_double_residual_csylv_dual ⭐

Returns 💖

See also 👀

Author ✍️

Date 📅

Definition 📍

✨ mepack_double_residual_glyap ✨

Purpose 🎯

Remarks 📝

Parameters 📋

Returns 💖

See also 👀

Author ✍️

Date 📅

Definition 📍

✨ mepack_double_residual_gstein ✨

Purpose 🎯

Remarks 📝

Parameters 📋

Returns 💖

See also 👀

Author ✍️

Date 📅

Definition 📍

✨ mepack_double_residual_gsylv ✨

Purpose 🎯

Remarks 📝

Parameters 📋

Returns

See also

Author

Date

Definition at line 170 of file gsylv.c.

💅 double mepack_double_residual_lyap (const char * TRANS, int M, double * A, int LDA, double * X, int LDX, double * Y, int LDY, double SCALE)

🌟 double mepack_double_residual_stein (const char * TRANS, int M, double * A, int LDA, double * X, int LDX, double * Y, int LDY, double SCALE)

🔥 double mepack_double_residual_sylv (const char * TRANSA, const char * TRANSB, double sgn, int M, int N, double * A, int LDA, double * B, int LDB, double * X, int LDX, double * Y, int LDY, double SCALE)

🌈 double mepack_double_residual_sylv2 (const char * TRANSA, const char * TRANSB, double sgn, int M, int N, double * A, int LDA, double * B, int LDB, double * X, int LDX, double * Y, int LDY, double SCALE)

Returns

See also

Author

Date

Definition

✨ float mepack_single_residual_csylv (const char * TRANSA, const char * TRANSB, float sgn1, float sgn2, int M, int N, float * A, int LDA, float * B, int LDB, float * C, int LDC, float * D, int LDD, float * R, int LDR, float * L, int LDL, float * E, int LDE, float * F, int LDF, float SCALE) ✨

Purpose

Remarks

Parameters

Returns

See also

Author

Date

Definition

Purpose

Remarks

Parameters

Returns

See also

Author

Date

Definition

✨ float mepack_single_residual_glyap (const char * TRANS, int M, float * A, int LDA, float * B, int LDB, float * X, int LDX, float * Y, int LDY, float SCALE) ✨

Purpose

Remarks

Parameters

🦋 mepack_single_residual_gstein

🎀 mepack_single_residual_gsylv

🌸 mepack_single_residual_lyap

🦋 mepack_single_residual_stein

💖 mepack_single_residual_sylv 💖

🦋 mepack_single_residual_sylv2 🦋

👑 Author 👑

🌈 Version 🌈

✨ `mepack_double_residual_glyap` ✨

✨ `mepack_double_residual_gstein` ✨

✨ `mepack_double_residual_gsylv` ✨

💅 `double mepack_double_residual_lyap (const char * TRANS, int M, double * A, int LDA, double * X, int LDX, double * Y, int LDY, double SCALE)`

🌟 `double mepack_double_residual_stein (const char * TRANS, int M, double * A, int LDA, double * X, int LDX, double * Y, int LDY, double SCALE)`

🔥 `double mepack_double_residual_sylv (const char * TRANSA, const char * TRANSB, double sgn, int M, int N, double * A, int LDA, double * B, int LDB, double * X, int LDX, double * Y, int LDY, double SCALE)`

🌈 `double mepack_double_residual_sylv2 (const char * TRANSA, const char * TRANSB, double sgn, int M, int N, double * A, int LDA, double * B, int LDB, double * X, int LDX, double * Y, int LDY, double SCALE)`

✨ `float mepack_single_residual_csylv (const char * TRANSA, const char * TRANSB, float sgn1, float sgn2, int M, int N, float * A, int LDA, float * B, int LDB, float * C, int LDC, float * D, int LDD, float * R, int LDR, float * L, int LDL, float * E, int LDE, float * F, int LDF, float SCALE)` ✨

✨ `float mepack_single_residual_glyap (const char * TRANS, int M, float * A, int LDA, float * B, int LDB, float * X, int LDX, float * Y, int LDY, float SCALE)` ✨

🦋 `mepack_single_residual_gstein`

🎀 `mepack_single_residual_gsylv`

🌸 `mepack_single_residual_lyap`

🦋 `mepack_single_residual_stein`

💖 `mepack_single_residual_sylv` 💖

🦋 `mepack_single_residual_sylv2` 🦋