ctgsylv(3)

📦

version 1.1.2 · 3 versions

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

✨ NAME ✨

ctgsylv — it's the C-Interface, bestie 💅

Okay so boom: ctgsylv is your girl for the C-Interface for triangular generalized Sylvester equations. That's it, that's the whole vibe — it's giving "C interface" and it's giving "triangular generalized Sylvester equations" and honestly? She ate. 👑

This is a page from the MEPACK manual, section 3 (that's library calls, iykyk 🦋). More sections coming, so stay tuned, don't go anywhere. 💖

✨ SYNOPSIS ✨

okay so bestie, this is the function roster. Every single one returns void, and they're all doing the same kind of mathematical slay but with different precision, variants, and scheduling. Let's get into it. 💅

🌸 Functions 🌸

mepack_double_tgcsylv_dag — Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation with DAG scheduling. Double precision, DAG scheduling, main character energy. 🦋

void mepack_double_tgcsylv_dag (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 *E, int
    LDE, double *F, int LDF, double *SCALE, double *WORK, int *INFO)

mepack_single_tgcsylv_dag — Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation with DAG scheduling. Same algorithm, but make it float, bestie. 💖

void mepack_single_tgcsylv_dag (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 *E, int LDE,
    float *F, int LDF, float *SCALE, float *WORK, int *INFO)

mepack_double_tgcsylv_dual_dag — OpenMP4 - DAG Algorithm for the dual generalized coupled Sylvester equation. It's giving dual, it's giving OpenMP4, it's giving DAG. 💅

void mepack_double_tgcsylv_dual_dag (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
    *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int
    *INFO)

mepack_single_tgcsylv_dual_dag — OpenMP4 - DAG Algorithm for the dual generalized coupled Sylvester equation. Single precision dual DAG, periodt. ✨

void mepack_single_tgcsylv_dual_dag (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 *E,
    int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

mepack_double_tgsylv_dag — Level-3 Bartels-Stewart Algorithm for the generalized Sylvester equation with DAG based parallelization. This is the generalized Sylvester one, not the coupled one. Iconic. 👑

void mepack_double_tgsylv_dag (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
    *SCALE, double *WORK, int *INFO)

mepack_single_tgsylv_dag — Level-3 Bartels-Stewart Algorithm for the generalized Sylvester equation with DAG based parallelization. Same DAG based parallelization, single precision cutie. 💜

void mepack_single_tgsylv_dag (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 *SCALE,
    float *WORK, int *INFO)

mepack_double_tgcsylv_level2 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation. Level-2 era, no cap. 💖

void mepack_double_tgcsylv_level2 (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
    *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int
    *INFO)

mepack_double_tgcsylv_level2_unopt — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Unoptimized variant). Yes, it's the unoptimized one, but still valid. 🫶

void mepack_double_tgcsylv_level2_unopt (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
    *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int
    *INFO)

mepack_double_tgcsylv_level2_reorder — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Reordered variant). Reordered and ready. 🎀

void mepack_double_tgcsylv_level2_reorder (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 *E, int LDE, double *F, int LDF, double *SCALE, double *WORK,
    int *INFO)

mepack_double_tgcsylv_level2_local_copy — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, unaligned). Local copies, unaligned, still cute. 🦋

void mepack_double_tgcsylv_level2_local_copy (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 *E, int LDE, double *F, int LDF, double *SCALE, double *WORK,
    int *INFO)

mepack_double_tgcsylv_level2_local_copy_32 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=32). M,N<=32, tiny but mighty. 🌸

void mepack_double_tgcsylv_level2_local_copy_32 (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 *E, int LDE, double *F, int LDF, double *SCALE, double
    *WORK, int *INFO)

mepack_double_tgcsylv_level2_local_copy_64 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=64). M,N<=64, slay. 💜

void mepack_double_tgcsylv_level2_local_copy_64 (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 *E, int LDE, double *F, int LDF, double *SCALE, double
    *WORK, int *INFO)

mepack_double_tgcsylv_level2_local_copy_96 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=96). M,N<=96, periodt. ⭐

void mepack_double_tgcsylv_level2_local_copy_96 (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 *E, int LDE, double *F, int LDF, double *SCALE, double
    *WORK, int *INFO)

mepack_double_tgcsylv_level2_local_copy_128 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=128). M,N<=128, iconic. 🔥

void mepack_double_tgcsylv_level2_local_copy_128 (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 *E, int LDE, double *F, int LDF, double *SCALE, double
    *WORK, int *INFO)

mepack_single_tgcsylv_level2 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation. Single precision level-2, bestie. 💅

void mepack_single_tgcsylv_level2 (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 *E,
    int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

mepack_single_tgcsylv_level2_unopt — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Unoptimized variant). Single precision unoptimized, still valid. 🫶

void mepack_single_tgcsylv_level2_unopt (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 *E,
    int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

mepack_single_tgcsylv_level2_reorder — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Reordered variant). Reordered, single precision. 🎀

void mepack_single_tgcsylv_level2_reorder (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
    *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int
    *INFO)

mepack_single_tgcsylv_level2_local_copy — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, unaligned). Single precision local copies, unaligned. 🦋

void mepack_single_tgcsylv_level2_local_copy (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
    *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int
    *INFO)

mepack_single_tgcsylv_level2_local_copy_32 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=32). M,N<=32, single precision, tiny queen. 🌸

void mepack_single_tgcsylv_level2_local_copy_32 (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int
    *INFO)

mepack_single_tgcsylv_level2_local_copy_64 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=64). M,N<=64, single precision, slay. 💜

void mepack_single_tgcsylv_level2_local_copy_64 (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int
    *INFO)

mepack_single_tgcsylv_level2_local_copy_96 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=96). M,N<=96, single precision, periodt. ⭐

void mepack_single_tgcsylv_level2_local_copy_96 (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int
    *INFO)

mepack_single_tgcsylv_level2_local_copy_128 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=128). M,N<=128, single precision, iconic. 🔥

void mepack_single_tgcsylv_level2_local_copy_128 (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int
    *INFO)

mepack_double_tgcsylv_dual_level2 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation. Dual level-2, bestie. 💅

void mepack_double_tgcsylv_dual_level2 (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
    *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int
    *INFO)

mepack_double_tgcsylv_dual_level2_local_copy — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation (Local copy variant). Local copy variant, obsessed. 🎀

void mepack_double_tgcsylv_dual_level2_local_copy (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 *E, int LDE, double *F, int LDF, double *SCALE, double
    *WORK, int *INFO)

mepack_double_tgcsylv_dual_level2_local_copy_32 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation (Local copy variant, M,N <= 32). M,N <= 32, tiny queen. 🌈

void mepack_double_tgcsylv_dual_level2_local_copy_32 (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 *E, int LDE, double *F, int LDF, double *SCALE,
    double *WORK, int *INFO)

mepack_double_tgcsylv_dual_level2_local_copy_64 — Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual

void mepack_double_tgcsylv_dual_level2_local_copy_64 (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 *E, int LDE, double *F, int LDF, double *SCALE,
    double *WORK, int *INFO)

okay so the next batch of prototypes is literally the whole tgcsylv / tgsylv family, and they all share the same shape — TRANSA, TRANSB, a sign (or two), M, N, then a parade of matrices, leading dimensions, SCALE, WORK and INFO 👀 watch this:

void mepack_double_tgcsylv_dual_level2_local_copy_96 (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 *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int *INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation, local-copy style, sized for M,N <= 96 💖

void mepack_double_tgcsylv_dual_level2_local_copy_128 (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 *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int *INFO)

same energy, same level-2 Kagstroem-Westin/Bartels-Stewart algorithm for the dual generalized coupled Sylvester equation, local copy variant but now it goes all the way to M,N <= 128 ✨

void mepack_single_tgcsylv_dual_level2 (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

the single-precision no-frills one 🎀 Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation. that's it, that's the whole vibe.

void mepack_single_tgcsylv_dual_level2_local_copy (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation, and this one is the Local Copies girlie 🫶

void mepack_single_tgcsylv_dual_level2_local_copy_32 (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation — Local Copies, and she's built for M,N <= 32 🌸

void mepack_single_tgcsylv_dual_level2_local_copy_64 (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

Local Copies again, this time the level-2 Kagstroem-Westin/Bartels-Stewart algorithm for the dual generalized coupled Sylvester equation handles M,N <= 64 💅

void mepack_single_tgcsylv_dual_level2_local_copy_96 (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

Local Copies, level-2 Kagstroem-Westin/Bartels-Stewart algorithm, dual generalized coupled Sylvester equation, M,N <= 96 — the middle child but make it ✨iconic✨

void mepack_single_tgcsylv_dual_level2_local_copy_128 (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

and the biggest local-copy one: Local Copies, level-2 Kagstroem-Westin/Bartels-Stewart algorithm for the dual generalized coupled Sylvester equation, M,N <= 128 👑

okay now we pivot to the non-dual generalized Sylvester equation squad 🦋 these ones take SGN (singular, bestie — not two), and they write into X with LDX instead of the E/F situation:

void mepack_double_tgsylv_level2_local_copy_32 (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 *SCALE, double *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, local copies, M,N<=32 💖

void mepack_double_tgsylv_level2_local_copy_64 (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 *SCALE, double *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, local copies, M,N<=64 ✨

void mepack_double_tgsylv_level2_local_copy_96 (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 *SCALE, double *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, local copies, M,N<=96 🎀

void mepack_double_tgsylv_level2_local_copy_128 (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 *SCALE, double *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, local copies, M,N<=128 — big-girl numbers, no cap 🌈

void mepack_double_tgsylv_level2_local_copy (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 *SCALE, double *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation — local copies, and this is the unaligned one, so she does not care about your alignment 😌

void mepack_double_tgsylv_level2_reorder (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 *SCALE, double *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, Reordered variant 🔥

void mepack_double_tgsylv_level2 (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 *SCALE, double *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation — the Classical level 2 variant, the original main character 💜

void mepack_double_tgsylv_level2_rowwise (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 *SCALE, double *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, Row-by-Row variant — she walks the rows, one at a time, no skips 🚶‍♀️

void mepack_double_tgsylv_level2_colwise (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 *SCALE, double *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, Column-by-column variant — column girlies rise 🌱

void mepack_double_tgsylv_gardiner_laub (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 *SCALE, double *WORK, int *INFO)

GARDINER-Laub Algorithm for the generalized Sylvester equation. yes, in all caps, and yes, she earned it 💅

and now the exact same tour again but in single precision, because equality 🌟

void mepack_single_tgsylv_level2_local_copy_32 (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 *SCALE, float *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, local copies, M,N<=32 🌸

void mepack_single_tgsylv_level2_local_copy_64 (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 *SCALE, float *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, local copies, M,N<=64 🎀

void mepack_single_tgsylv_level2_local_copy_96 (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 *SCALE, float *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, local copies, M,N<=96 ✨

void mepack_single_tgsylv_level2_local_copy_128 (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 *SCALE, float *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, local copies, M,N<=128 👑

void mepack_single_tgsylv_level2_local_copy (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 *SCALE, float *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation — local copies, unaligned, zero alignment opinions 🫶

void mepack_single_tgsylv_level2_reorder (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 *SCALE, float *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, the Reordered variant 🔥

void mepack_single_tgsylv_level2 (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 *SCALE, float *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation — the Classic level 2variant 💜 (yes the docs really did fuse those two words together, and honestly? iconic typo, we respect it)

void mepack_single_tgsylv_level2_rowwise (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 *SCALE, float *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, Row-by-row variant — lowercase row, same slay 🌈

void mepack_single_tgsylv_level2_colwise (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 *SCALE, float *WORK, int *INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation, Column-by-column variant 🌱

void mepack_single_tgsylv_gardiner_laub (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 *SCALE, float *WORK, int *INFO)

Gardiner-Laub Algorithm for the generalized Sylvester equation — the single-precision edition, title case this time, she contains multitudes 🌸

void mepack_double_tgcsylv_level3 (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 *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int *INFO)

✨ the Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation, double precision, bestie 💖

void mepack_double_tgcsylv_level3_unopt (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 *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int *INFO)

the Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation, but the Unoptimized variant 🫶

void mepack_double_tgcsylv_level3_2stage (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 *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int *INFO)

the Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm with sub-blocking for the generalized coupled Sylvester equation 🦋

void mepack_single_tgcsylv_level3 (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation, single precision edition 💅

void mepack_single_tgcsylv_level3_unopt (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation 🌸

void mepack_single_tgcsylv_level3_2stage (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation 💜

void mepack_double_tgcsylv_dual_level3 (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 *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int *INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation, double precision 😌

void mepack_single_tgcsylv_dual_level3 (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation, single precision 🎀

void mepack_double_tgcsylv_dual_level3_2stage (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 *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int *INFO)

Level-3 with sub blocking Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation, double precision 🌈

void mepack_single_tgcsylv_dual_level3_2stage (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm with sub blocking for the dual generalized coupled Sylvester equation, single precision ✨

void mepack_double_tgsylv_level3 (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 *SCALE, double *WORK, int *INFO)

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester equation, double precision 👑

void mepack_double_tgsylv_level3_rowwise (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 *SCALE, double *WORK, int *INFO)

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester equation, the Row-by-row variant 🍓

void mepack_double_tgsylv_level3_colwise (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 *SCALE, double *WORK, int *INFO)

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester equation, the Column-by-Column variant 🍓

void mepack_double_tgsylv_level3_2stage (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 *SCALE, double *WORK, int *INFO)

Level-3 Bartels-Stewart Algorithm with sub-blocking for the generalized Sylvester equation, double precision 🧚

void mepack_single_tgsylv_level3 (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 *SCALE, float *WORK, int *INFO)

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester, single precision 💖

void mepack_single_tgsylv_level3_rowwise (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 *SCALE, float *WORK, int *INFO)

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester, the Row-by-row variant 🎀

void mepack_single_tgsylv_level3_colwise (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 *SCALE, float *WORK, int *INFO)

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester, the Column-by-column variant 🎀

void mepack_single_tgsylv_level3_2stage (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 *SCALE, float *WORK, int *INFO)

Level-3 Bartels-Stewart Algorithm with sub-blocking for the generalized Sylvester, single precision 🦋

void mepack_double_tgcsylv_recursive (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 *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int *INFO)

Recursive blocking Algorithm for the generalized coupled Sylvester equation, double precision 🔥

void mepack_single_tgcsylv_recursive (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

Recursive blocking Algorithm for the generalized coupled Sylvester equation, single precision 🔥

void mepack_double_tgcsylv_dual_recursive (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 *E, int LDE, double *F, int LDF, double *SCALE, double *WORK, int *INFO)

Recursive blocking algorithm for the dual generalized coupled Sylvester equation, double precision 💜

void mepack_single_tgcsylv_dual_recursive (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 *E, int LDE, float *F, int LDF, float *SCALE, float *WORK, int *INFO)

Recursive blocking algorithm for the dual generalized coupled Sylvester equation, single precision 💜

void mepack_double_tgsylv_recursive (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 *SCALE, double *WORK, int *INFO)

Recursive blocking Algorithm for the generalized Sylvester equation, double precision ⭐

void mepack_single_tgsylv_recursive (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 *SCALE, float *WORK, int *INFO)

Recursive blocking algorithm for the generalized Sylvester equation, single precision ⭐

✨ Detailed Description ✨

C-Interface for triangular generalized Sylvester equations. 💖

okay so basically: the Fortran routines that solve the generalized Sylvester equation with triangular coefficients get wrapped in C so you can actually reach them without losing your whole entire mind. Every single wrapper routine here is a direct wrapper to the corresponding Fortran subroutine — no sanity checks 🙈 — because the Fortran routines are the ones doing the checking. So like, behave, bestie.

and here's the catch: since these routines use int values to pass sizes, the work_space query will fail for large scale problems 💀. so for that you gotta use mepack_memory to query the required work_space from C code. that function is aware of 64 bit integers if MEPACK is compiled with it. no cap. ✨

💅 Function Documentation 💅

🦋 `void mepack_double_tgcsylv_dag (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)`

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation with DAG scheduling. 👑

🎀 Purpose:

mepack_double_tgcsylv_dag solves a generalized coupled Sylvester equation of the following form:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

so like — where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix, and B and D are N-by-N upper triangular matrices 💫. and plot twist: either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. iykyk 🧚

💀 Remarks

The function is a wrapper for dla_tgcsylv_dag ✨

Parameters 🎀

TRANSA — it's a String, and it sets the form of the system of equations when it comes to A and C:
- == 'N': op1(A) = A, op1(C) = C (no transpose for A and C, we're keeping it chill)
- == 'T': op1(A) = A**T, op1(C) = C **T (transpose A and C, flipping the whole vibe)
TRANSB — also a String, same deal but for B and D:
- == 'N': op2(B) = B, op2(D) = D (no transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (transpose B and D)
SGN1 — a DOUBLE PRECISION, allowed values +/-1. It specifies the sign between the terms in the first equation. ✨
SGN2 — a DOUBLE PRECISION, allowed values +/-1. It specifies the sign between the terms in the second equation.
M — INTEGER. The order of the matrices A and C. M >= 0.
N — INTEGER. The order of the matrices B and D. N >= 0.
A — a DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular, no exceptions 💅
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — a DOUBLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. But heads up: if the matrix D is already quasi-upper triangular, then the matrix B must be plain upper triangular. It's giving ✨trading constraints✨.
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — a DOUBLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — a DOUBLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. And same plot twist as before: if the matrix B is already quasi-upper triangular, then the matrix D must be upper triangular.
LDD — INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — a DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. She's a dual-purpose queen 👑
LDE — INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — a DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — INTEGER. The leading dimension of the array F. LDE >= max(1,M).

okay yes, that literally says LDE and not LDF in the LDF description — not me catching that, it's just what the docs say bestie, I'm not touching it 🫶

SCALE — a DOUBLE PRECISION. SCALE is a scaling factor to prevent overflow in the result. If INFO == 0 then SCALE is 1.0D0, otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — a DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. And no cap, you gotta query the workspace before running the computation — you do that by calling the subroutine with INFO == -1 on input, and the required workspace comes back to you in INFO. So iconic 🌈
INFO — INTEGER. Here's the whole lore:
- On input:
 - == -1: Perform a workspace query
 - <> -1: normal operation
- On exit, workspace query:
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - >= 0: the value of INFO is the required number of elements in the workspace
- On exit, normal operation:
 - == 0: successful exit 🎉
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: the equation is not solved correctly. One of the arising inner system got singular. 💀

Author — Martin Koehler, MPI Magdeburg

Date — October 2025

Definition at line 214 of file tgcsylv.c.

`void mepack_double_tgcsylv_dual_dag` ( ... )

void mepack_double_tgcsylv_dual_dag (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 *
    E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int *
    INFO)

OpenMP4 - DAG Algorithm for the dual generalized coupled Sylvester equation. Okay she's fancy AND parallel, we love to see it 🦋

Purpose 🌸

mepack_double_tgcsylv_dual_dag solves a generalized coupled Sylvester equation that looks like this:

   op1(A)**T * R  + op1(C)**T * L               = SCALE * E                             (1)
   SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix, and B and D are N-by-N upper triangular matrices. And plot twist: either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) (or (D,B)) are created by DGGES from LAPACK. iykyk 💅

The equation (1) is the dual to the generalized coupled Sylvester equation

   op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
   op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

Equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. That gives you:

        | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
  Z X = |                                           |*|       | = |       |
        | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

And when you look at Z**T, you get:

           | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
  Z**T X = |                                             |*|       | = |       |
           | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). And that's the reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2). Periodt. 🎀

Remarks 🙈

This function is a wrapper for dla_tgcsylv_dual_dag. She's the face, dla_tgcsylv_dual_dag is the engine, we respect both.

Parameters 💜

TRANSA — CHARACTER(1). Sets the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (no transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (transpose A and C)
TRANSB — CHARACTER(1). Sets the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (no transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (transpose B and D)
SGN1 — DOUBLE PRECISION, allowed values +/-1. It specifies the sign between the terms in the first equation.
SGN2 — DOUBLE PRECISION, allowed values +/-1. It specifies the sign between the terms in the second equation.
M — INTEGER. The order of the matrices A and C. M >= 0.
N — INTEGER. The order of the matrices B and D. N >= 0.
A — DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — DOUBLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular, the matrix B must be upper triangular.
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — DOUBLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — DOUBLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular, the matrix D must be upper triangular.
LDD — INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE — INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — INTEGER. The leading dimension of the array F. LDE >= max(1,M).
SCALE — DOUBLE PRECISION. SCALE is a scaling factor to prevent overflow in the result. If INFO == 0 then SCALE is 1.0D0, otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — DOUBLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory.
INFO — INTEGER. Here's the rundown:
- On input:
 - == -1: Perform a workspace query (not recommended in the C interface)
 - <> -1: normal operation
- On exit, workspace query:
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - >= 0: the value of INFO is the required number of elements in the workspace

On exit, normal operation:

== 0: successful exit ✨
< 0: if INFO == -i, the i-Th argument had an illegal value 🙈
> 0: The equation is not solved correctly. One of the arising inner system got singular. 💀

Author — Martin Koehler, MPI Magdeburg

Date — October 2025

Definition at line 232 of file tgcsylv_dual.c.

🫶 `void mepack_double_tgcsylv_dual_level2 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)`

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation. 👑

Purpose:

okay so mepack_double_tgcsylv_dual_level2 solves a generalized coupled Sylvester equation of the following form, bestie:

op1(A)**T * R  + op1(C)**T * L               = SCALE * E                             (1)
SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. 🌈

The equation (1) is the dual to the generalized coupled Sylvester equation

op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

        | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
  Z X = |                                           |*|       | = |       |
        | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

           | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
  Z**T X = |                                             |*|       | = |       |
           | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2). no cap, that's literally the whole reason 💅

Remarks

This function is a wrapper for dla_tgcsylv_dual_l2. 🎀

See also

dla_tgcsylv_dual_l2

Parameters

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. ✨
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. ✨
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is DOUBLE PRECISION array, dimension (LDE,N).
- On input, the matrix E contains the right hand side E.
- On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2.
- Right hand side E and the solution R are M-by-N matrices.
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is DOUBLE PRECISION array, dimension (LDF,N).
- On input, the matrix F contains the right hand side F.
- On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2.
- Right hand side F and the solution L are M-by-N matrices.
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (yes bestie, it really does say LDE there, we don't make the rules 🙈)
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is DOUBLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory.
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query ( not recommended in the C interface)
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit ✨
< 0: if INFO == -i, the i-Th argument had an illegal value 🙈
> 0: The equation is not solved correctly. One of the arising inner system got singular. 💀

Author — Martin Koehler, MPI Magdeburg

Date — October 2025

Definition at line 231 of file tgcsylv_dual.c.

🦋 `void mepack_double_tgcsylv_dual_level2_local_copy (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)`

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation (Local copy variant) 💖

Purpose:

mepack_double_tgcsylv_dual_level2_local_copy solves a generalized coupled Sylvester equation of the following form

op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

The equation (1) is the dual to the generalized coupled Sylvester equation

op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

        | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
  Z X = |                                           |*|       | = |       |
        | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

           | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
  Z**T X = |                                             |*|       | = |       |
           | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2). 🧚

Remarks

This function is a wrapper for dla_tgcsylv_dual_l2_local_copy.

See also

dla_tgcsylv_dual_l2_local_copy

Parameters

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
LDB — LDB is INTEGER. It's the leading dimension of the array B, and the vibe check says LDB >= max(1,N). 💖
C — C is a DOUBLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular. That's not optional, bestie, it's giving "upper triangular only". ✨
LDC — LDC is INTEGER. Leading dimension of the array C, and LDC >= max(1,M). Periodt. 💅
D — D is a DOUBLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. And here's the tea: if the matrix B is already quasi-upper triangular, then D must be upper triangular. 🫶
LDD — LDD is INTEGER. Leading dimension of the array D, and LDD >= max(1,N). Slay. 🌸
E — E is a DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. The right hand side E and the solution R are M-by-N matrices. Main character energy, honestly. 👑
LDE — LDE is INTEGER. Leading dimension of the array E, and LDE >= max(1,M). 🌈
F — F is a DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and solution L are both M-by-N matrices. Iconic. ⭐
LDF — LDF is INTEGER. Leading dimension of the array F. And the doc says LDE >= max(1,M) — yes, we're all looking at it, it says LDE, and I'm reporting it exactly as written, no notes. 🙈
SCALE — SCALE is DOUBLE PRECISION. It's the scaling factor that stops the result from overflowing, and it's lowkey the hero of the whole thing. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems couldn't be solved correctly, then 0 < SCALE <= 1 holds true. 💜
WORK — WORK is a DOUBLE PRECISION array, dimension (MAX(1,LDWORK)). It's the workspace for the algorithm, and the optimal workspace is given by \ref mepack_memory. ✨
INFO — INFO is INTEGER. She's got layers, so let's break it down:

On input:
  == -1 : Perform a workspace query ( not recommended in the C interface)
  <> -1 : normal operation

On exit, workspace query:
  < 0 :  if INFO == -i, the i-Th argument had an illegal value
  >= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:
  == 0:  successful exit
  < 0:  if INFO == -i, the i-Th argument had an illegal value
  > 0:  The equation is not solved correctly. One of the arising inner
        system got singular.

👑 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

📍 Definition

Definition at line 460 of file tgcsylv_dual.c.

🦋 `mepack_double_tgcsylv_dual_level2_local_copy_128`

void mepack_double_tgcsylv_dual_level2_local_copy_128 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK,
    int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation (Local copy variant, M,N <= 128)

🎯 Purpose

mepack_double_tgcsylv_dual_level2_local_copy_128 solves a generalized coupled Sylvester equation of the following form

   op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
   SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK.

The equation (1) is the dual to the generalized coupled Sylvester equation

   op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
   op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

               | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
         Z X = |                                           |*|       | = |       |
               | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

                  | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
         Z**T X = |                                             |*|       | = |       |
                  | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2).

💭 Remarks

This function is a wrapper for dla_tgcsylv_dual_l2_local_copy_128.

👀 See also

dla_tgcsylv_dual_l2_local_copy_128

🎀 Parameters

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. 💅
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. 💅
M — M is INTEGER. The order of the matrices A and C. M >= 0. ✨
N — N is INTEGER. The order of the matrices B and D. N >= 0. ✨
A — A is a DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. 🌸
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M). 🫶
B — B is a DOUBLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 🌈
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N). 💖
C — C is a DOUBLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular. Periodt. 💅
LDC — LDC is INTEGER. The leading dimension of the array C. LDC >= max(1,M). 🌸
D — D is a DOUBLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 🦋
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N). ✨
E — E is a DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 👑
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M). ⭐
F — F is a DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. 💜
LDF — LDF is INTEGER. The leading dimension of the array F. And once again the doc says LDE >= max(1,M) — reporting it exactly as it stands, no edits from me. 🙈
SCALE — SCALE is DOUBLE PRECISION. A scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. ✨
WORK — WORK is a DOUBLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory. 🎀
INFO — INFO is INTEGER:

On input:
  == -1 : Perform a workspace query ( not recommended in the C interface)
  <> -1 : normal operation

On exit, workspace query:
  < 0 :  if INFO == -i, the i-Th argument had an illegal value
  >= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:
  == 0:  successful exit
  < 0:  if INFO == -i, the i-Th argument had an illegal value
  > 0:  The equation is not solved correctly. One of the arising inner
        system got singular.

👑 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

📍 Definition

Definition at line 1376 of file tgcsylv_dual.c.

🧚 `mepack_double_tgcsylv_dual_level2_local_copy_32`

void mepack_double_tgcsylv_dual_level2_local_copy_32 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK,
    int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation (Local copy variant, M,N <= 32)

🎯 Purpose

mepack_double_tgcsylv_dual_level2_local_copy_32 solves a generalized coupled Sylvester equation of the following form

   op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
   SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

The equation (1) is the dual to the generalized coupled Sylvester equation

     op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
     op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

So equation (1) is the dual of equation (2) with respect to the underlying linear system, bestie. Like, they're mirrors. 💫 Let Z be the matrix you get by rewriting (2) into its Kronecker form. Which gives you:

        | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
  Z X = |                                           |*|       | = |       |
        | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

And then looking at Z**T, you get:

           | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
  Z**T X = |                                             |*|       | = |       |
           | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). ✨ And that's literally why the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2). iykyk 🧠

🌸 Remarks 🌸

This function is a wrapper for dla_tgcsylv_dual_l2_local_copy_32. it's giving "delegation, but make it chic" 💅

👀 See also 👀

dla_tgcsylv_dual_l2_local_copy_32

🎀 Parameters 🎀

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. yes, it's just a sign, but it's load-bearing bestie 🙈
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. same energy, second equation 💖
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. no cap, it has to be 📐
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. read that twice, it's a whole vibe check ⚠️
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 matrix C must be upper triangular. strictly upper triangular, she doesn't do quasi ✋
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. the ✨reciprocal✨ of the B situation, obsessed 🦋
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. she transforms on the way out, main character energy 👑
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (yes, it says LDE in the original, we do not correct the manpage, we simply report it 💀)
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. it's the seatbelt of this whole operation 🫶
WORK — WORK is DOUBLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory.
INFO — INFO is INTEGER.
- On input:
 - == -1 : Perform a workspace query ( not recommended in the C interface)
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

heads up: that INFO > 0 case is not a "lol whatever" situation — one of the inner systems went singular and the equation did not get solved correctly. 😭

✍️ Author ✍️

Martin Koehler, MPI Magdeburg

📅 Date 📅

October 2025

Definition at line 689 of file tgcsylv_dual.c.

🦋 `void mepack_double_tgcsylv_dual_level2_local_copy_64 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)` 🦋

void mepack_double_tgcsylv_dual_level2_local_copy_64 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK,
    int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation (Local copy variant, M,N <= 64)

okay so this is the 64 version, the bigger sibling of the 32 one. same algorithm, same energy, just built for when your matrices are up to M,N <= 64. 💖

✨ Purpose ✨

mepack_double_tgcsylv_dual_level2_local_copy_64 solves a generalized coupled Sylvester equation of the following form

   op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
   SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

The equation (1) is the dual to the generalized coupled Sylvester equation

   op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
   op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

        | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
  Z X = |                                           |*|       | = |       |
        | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

           | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
  Z**T X = |                                             |*|       | = |       |
           | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2). 🌈

🌸 Remarks 🌸

This function is a wrapper for dla_tgcsylv_dual_l2_local_copy_64. 💅

👀 See also 👀

dla_tgcsylv_dual_l2_local_copy_64

🎀 Parameters 🎀

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. ✨
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. ✨
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. ⚠️
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. ⚠️
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 💖
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F —
F — it's a DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. 💅
LDF — INTEGER, bestie. It's the leading dimension of the array F. So: LDE >= max(1,M).
SCALE — DOUBLE PRECISION. This is the scaling factor whose whole job is to stop the result from overflowing 🌊. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — DOUBLE PRECISION array, dimension (MAX(1,LDWORK)). It's the workspace for the algorithm 🛠️, and the optimal workspace is given by \ref mepack_memory.
INFO — INTEGER. She's the receipts, periodt:
- On input:
 - == -1 : Perform a workspace query ( not recommended in the C interface)
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

🫶 Author 🫶

Martin Koehler, MPI Magdeburg

🎀 Date 🎀

October 2025

📍 Definition 📍

Definition at line 917 of file tgcsylv_dual.c.

`void mepack_double_tgcsylv_dual_level3 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)`

void mepack_double_tgcsylv_dual_level3 (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 *
    E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int *
    INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation. 👑

✨ Purpose ✨

mepack_double_tgcsylv_dual_level3 solves a generalized coupled Sylvester equation of the following form:

   op1(A)**T * R  + op1(C)**T * L               = SCALE * E                             (1)
   SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK.

The equation (1) is the dual to the generalized coupled Sylvester equation:

   op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
   op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields:

        | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
  Z X = |                                           |*|       | = |       |
        | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains:

           | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
  Z**T X = |                                             |*|       | = |       |
           | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2). 🌀

💜 Remarks 💜

This function is a wrapper for dla_tgcsylv_dual_l3.

🌈 See also 🌈

dla_tgcsylv_dual_l3

🌸 Parameters 🌸

TRANSA
TRANSA — bestie, this one's a CHARACTER(1) and it tells us the form of the system of equations with respect to A and C. The options, verbatim:

== 'N':  op1(A) = A, op1(C) = C (No transpose for A and C)
== 'T':  op1(A) = A**T, op1(C) = C **T (Transpose A and C)

So 'N' = no transpose, 'T' = transpose. Periodt. 💅

TRANSB — also a CHARACTER(1), but this one's about the form of the system of equations with respect to B and D:

== 'N':  op2(B) = B, op2(D) = D (No transpose for B and D)
== 'T':  op2(B) = B**T, op2(D) = D **T (Transpose B and D)

SGN1 — a DOUBLE PRECISION, and the allowed values are +/-1. It specifies the sign between in the first equation. 🎀
SGN2 — also DOUBLE PRECISION, allowed values +/-1, and it specifies the sign between in the second equation. Matching set, we love to see it. ✨
M — an INTEGER. The order of the matrices A and C. Constraint: M >= 0.
N — an INTEGER. The order of the matrices B and D. Constraint: N >= 0.
A — a DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. no cap.
LDA — an INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — a DOUBLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. And heads up: if the matrix D is already quasi-upper triangular, then the matrix B must be upper triangular. 👀
LDB — an INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — a DOUBLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — an INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — a DOUBLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. And same deal as before, flipped: if the matrix B is already quasi-upper triangular, then the matrix D must be upper triangular. 🔄
LDD — an INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — a DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1), as selected by TRANSA, TRANSB, and SGN1/SGN2. Both the right hand side E and the solution R are M-by-N matrices. she's a multitasker 💖
LDE — an INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — a DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1), as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and solution L are M-by-N matrices.
LDF — an INTEGER. The leading dimension of the array F. LDE >= max(1,M). (yes, that's what the docs say — it says LDE in the LDF entry, and we are simply reporting the lore as it was written 📖)
SCALE — a DOUBLE PRECISION. It's a scaling factor to prevent overflow in the result. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. 🫶
WORK — a DOUBLE PRECISION array, dimension (MAX(1,LDWORK)). It's the workspace for the algorithm. The optimal workspace is given by \ref mepack_memory.
INFO — an INTEGER. Bestie, read this one slowly because it changes meaning depending on when you look at it:

On input:
  == -1 : Perform a workspace query ( not recommended in the C interface)
  <> -1 : normal operation

On exit, workspace query:
  < 0 :  if INFO == -i, the i-Th argument had an illegal value
  >= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:
  == 0:  successful exit
  < 0:  if INFO == -i, the i-Th argument had an illegal value
  > 0:  The equation is not solved correctly. One of the arising inner
        system got singular.

so real talk: INFO > 0 means the equation isn't solved correctly because one of the arising inner systems got singular. That's not a vibe, that's a genuine "your answer is not trustworthy" situation. 🙈

👑 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

Definition at line 231 of file tgcsylv_dual.c.

✨ `void mepack_double_tgcsylv_dual_level3_2stage (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)` ✨

Level-3 with sub blocking Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation. okay she has a whole title, main character energy fr fr 💅

void mepack_double_tgcsylv_dual_level3_2stage (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK,
    int * INFO)

🌸 Purpose:

mepack_double_tgcsylv_dual_level3_2stage solves a generalized coupled Sylvester equation of the following form

op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. 🔥

The equation (1) is the dual to the generalized coupled Sylvester equation

op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

       | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
 Z X = |                                           |*|       | = |       |
       | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

          | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
 Z**T X = |                                             |*|       | = |       |
          | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2). 🦋

💀 Remarks

This function is a wrapper for dla_tgcsylv_dual_l3_2s.

👀 See also

dla_tgcsylv_dual_l3_2s

🎀 Parameters

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A and C:

== 'N':  op1(A) = A, op1(C) = C (No transpose for A and C)
== 'T':  op1(A) = A**T, op1(C) = C **T (Transpose A and C)

TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B and D:

== 'N':  op2(B) = B, op2(D) = D (No transpose for B and D)
== 'T':  op2(B) = B**T, op2(D) = D **T (Transpose B and D)

SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. ⭐
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. ⭐
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 💖
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. 💖
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (again — the original says LDE here, we're just the messenger 🧚)
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is DOUBLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory.
INFO — INFO is INTEGER.

On input:
  == -1 : Perform a workspace query ( not recommended in the C interface)
  <> -1 : normal operation

On exit, workspace query:
  < 0 :  if INFO == -i, the i-Th argument had an illegal value
  >= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation does its thing 💅
- == 0: successful exit — we love to see it ✨
- < 0: if INFO == -i, the i-Th argument had an illegal value (bestie, check ur args)
- > 0: The equation is not solved correctly. One of the arising inner system got singular. 💀

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 687 of file tgcsylv_dual.c.

🫶 `mepack_double_tgcsylv_dual_recursive` 🫶

okay so here's the whole signature, exactly as it lives, no cap:

void mepack_double_tgcsylv_dual_recursive (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 *
    E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int *
    INFO)

Recursive blocking algorithm for the dual generalized coupled Sylvester equation. 🦋

💖 Purpose 💖

so mepack_double_tgcsylv_dual_recursive solves a generalized coupled Sylvester equation that looks like this:

   op1(A)**T * R  + op1(C)**T * L               = SCALE * E                             (1)
   SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

(yes, that op2(D)** T has a space in it, and yes, we are keeping it exactly like that 😭 do not touch it)

Where, listen:

A is a M-by-M quasi upper triangular matrix 🌸
C is a M-by-M upper triangular matrix
B and D are N-by-N upper triangular matrices
and furthermore either B or D can be quasi upper triangular as well
the right hand side Y and the solution X are M-by-N matrices
Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK.

The equation (1) is the dual to the generalized coupled Sylvester equation

   op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
   op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

Equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

        | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
  Z X = |                                           |*|       | = |       |
        | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

and regarding Z**T one obtains

           | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
  Z**T X = |                                             |*|       | = |       |
           | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2). ✨ iykyk

🎀 Remarks 🎀

This function is a wrapper for dla_tgcsylv_dual_recursive. 🫶

🦋 See also 🦋

dla_tgcsylv_dual_recursive

🌸 Parameters 🌸

TRANSA — TRANSA is CHARACTER(1)
- Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is CHARACTER(1)
- Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1
- Specifies the sign between in the first equation.
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1
- Specifies the sign between in the second equation.
M — M is INTEGER
- The order of the matrices A and C. M >= 0.
N — N is INTEGER
- The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M)
- The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER
- The leading dimension of the array D. LDD >= max(1,N).
E — E is DOUBLE PRECISION array, dimension (LDE,N)
- On input, the matrix E contains the right hand side E.
- On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2.
- Right hand side E and the solution R are M-by-N matrices. 🌈
LDE — LDE is INTEGER
- The leading dimension of the array E. LDE >= max(1,M).
F — F is DOUBLE PRECISION array, dimension (LDF,N)
- On input, the matrix F contains the right hand side F.
- On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2.
- Right hand side F and the solution L are M-by-N matrices. 💜
LDF — LDF is INTEGER
- The leading dimension of the array F. LDE >= max(1,M).

⚠️ bestie that's not a typo on my end — the original literally says LDE >= max(1,M) under LDF. keep it fr fr.

SCALE — SCALE is DOUBLE PRECISION
- SCALE is a scaling factor to prevent the overflow in the result.
- If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is DOUBLE PRECISION array, dimension (MAX(1,LDWORK))
- Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory.
INFO — INFO is INTEGER
- On input:
 - == -1 : Perform a workspace query ( not recommended in the C interface)
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit ✨
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular. 💀

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 231 of file tgcsylv_dual.c.

🔥 `mepack_double_tgcsylv_level2` 🔥

void mepack_double_tgcsylv_level2 (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 * E, int LDE,
    double * F, int LDF, double * SCALE, double * WORK, int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation. 👑

💖 Purpose 💖

mepack_double_tgcsylv_level2 solves a generalized coupled Sylvester equation of the following form

   op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
   op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. 🦋

🎀 Remarks 🎀

The function is a wrapper for dla_tgcsylv_l2. 🫶

🦋 See also 🦋

dla_tgcsylv_l2

🌸 Parameters 🌸

TRANSA — TRANSA is String
- Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String
- Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1
- Specifies the sign between in the first equation.
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1
- Specifies the sign between in the second equation.
M — M is INTEGER
- The order of the matrices A and C. M >= 0.
N — N is INTEGER
- The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M)
- The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER
- The leading dimension of the array D. LDD >= max(1,N).
E — E is DOUBLE PRECISION array, dimension (LDE,N)
- On input, the matrix E contains the right hand side E.
- On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2.
- Right hand side E and the solution R are M-by-N matrices. ⭐
LDE —
LDE — LDE is INTEGER, bestie, and it's the leading dimension of the array E. Rule of the land: LDE >= max(1,M). 💅
F — F is DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. ✨
LDF — LDF is INTEGER, the leading dimension of the array F. And yes, the original really does say LDE >= max(1,M) right here, we are not fixing it, we are reporting it, fr fr. 💀
SCALE — SCALE is DOUBLE PRECISION. It's a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0, otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. 🫶
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. It's workspace for the algorithm. The workspace needs to queried before the running the computation (their words, iconic grammar, we stan). The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. 🔥
INFO — INFO is INTEGER. Buckle up, it's giving multi-mode:
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

Author 👑

Martin Koehler, MPI Magdeburg

Date 📅

October 2025

Definition at line 214 of file tgcsylv.c.

`void mepack_double_tgcsylv_level2_local_copy (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)`

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, unaligned) ✨

Purpose:

mepack_double_tgcsylv_level2_local_copy solves a generalized coupled Sylvester equation of the following form, and yes it's a whole mood:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

Remarks

The function is a wrapper for dla_tgcsylv_l2_local_copy. (Just a lil handoff, no cap. 💅)

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 🌸
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (Same lil typo, same energy, we report it faithfully. 💀)
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER.
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

Author 👑

Martin Koehler, MPI Magdeburg

Date 📅

October 2025

Definition at line 847 of file tgcsylv.c.

`void mepack_double_tgcsylv_level2_local_copy_128 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)`

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=128) ✨

Purpose:

mepack_double_tgcsylv_level2_local_copy_128 solves a generalized coupled Sylvester equation of the following form:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

Remarks

The function is a wrapper for dla_tgcsylv_l2_local_copy_128. (The _128 sibling, same vibe, different size gate. 💅)

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
LDC — LDC is INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D
D — D is a DOUBLE PRECISION array, dimension (LDD,N). Bestie, this matrix must be (quasi-) upper triangular. And heads up: if matrix B is already quasi-upper triangular, then D has to be plain upper triangular. no exceptions 💅
LDD — LDD is INTEGER. It's the leading dimension of the array D. LDD >= max(1,N). fr fr.
E — E is a DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E holds the right hand side E. On output, the matrix E holds the solution R of Equation (1), as selected by TRANSA, TRANSB, and SGN1/SGN2. Both the right hand side E and the solution R are M-by-N matrices. she's a glow-up on the way out ✨
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is a DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F holds the right hand side F. On output, the matrix F holds the solution L of Equation (1), as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are both M-by-N matrices. 💖
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (yes, the source literally says LDE here, we're just telling you what it says, don't @ me 🙈)
SCALE — SCALE is DOUBLE PRECISION. She's a scaling factor whose whole job is to stop the result from overflowing. If INFO == 0 then SCALE is 1.0D0, otherwise — if one of the inner systems couldn't be solved correctly — 0 < SCALE <= 1 holds true. 🫶
WORK — WORK is a DOUBLE PRECISION array, dimension LDWORK. It's the workspace for the algorithm. Important: you gotta query the workspace before you run the computation. You do that by calling the subroutine with INFO == -1 on input. The required workspace then comes back to you in INFO. main character move, honestly 👑
INFO — INFO is INTEGER.

On input:

== -1 : perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-th argument had an illegal value
>= 0: the value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit, slay 🎀
< 0: if INFO == -i, the i-th argument had an illegal value
> 0: the equation is not solved correctly. One of the arising inner system got singular. 💀

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition

Definition at line 1688 of file tgcsylv.c.

🌸 mepack_double_tgcsylv_level2_local_copy_32 🌸

void mepack_double_tgcsylv_level2_local_copy_32 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK,
    int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=32).

Purpose:

mepack_double_tgcsylv_level2_local_copy_32 solves a generalized coupled Sylvester equation that looks like this:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix, and B and D are N-by-N upper triangular matrices. Also, either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. iykyk 💫

Remarks

The function is a wrapper for dla_tgcsylv_l2_local_copy_32.

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is a DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — B is a DOUBLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — C is a DOUBLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — LDC is INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — D is a DOUBLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is a DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is a DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (yep, still says LDE, quoted verbatim 💜)
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is a DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition

Definition at line 1058 of file tgcsylv.c.

🦋 mepack_double_tgcsylv_level2_local_copy_64 🦋

void mepack_double_tgcsylv_level2_local_copy_64 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK,
    int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=64).

Purpose:

mepack_double_tgcsylv_level2_local_copy_64 solves a generalized coupled Sylvester equation of the following form:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. obsessed with her honestly 🌈

Remarks

The function is a wrapper for dla_tgcsylv_l2_local_copy_64.

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is a DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
LDA — LDA is INTEGER, bestie. It's the leading dimension of the array A, and you need LDA >= max(1,M). no cap, don't skimp on this one 💅
B — B is DOUBLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. And listen — if the matrix D is already quasi-upper triangular, then the matrix B must be upper triangular. it's giving ✨conditional requirements✨ fr fr
LDB — LDB is INTEGER. Leading dimension of the array B, and LDB >= max(1,N). periodt 🎀
C — C is DOUBLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular. that's it, that's the vibe 🌸
LDC — LDC is INTEGER. Leading dimension of the array C, with LDC >= max(1,M). 🦋
D — D is DOUBLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. And the flip side of earlier: if the matrix B is already quasi-upper triangular, then the matrix D must be upper triangular. iconic reciprocity tbh 👑
LDD — LDD is INTEGER. Leading dimension of the array D, and LDD >= max(1,N). 💜
E — E is DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. glow-up arc honestly 😭💖
LDE — LDE is INTEGER. Leading dimension of the array E, and LDE >= max(1,M). ⭐
F — F is DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. same energy as E but make it F 💅
LDF — LDF is INTEGER. Leading dimension of the array F. LDE >= max(1,M). (yes it literally says LDE in the source, we're keeping it exactly as written, no edits bestie 🫶)
SCALE — SCALE is DOUBLE PRECISION. It's a scaling factor whose whole job is to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0, otherwise — if one of the inner systems could not be solved correctly — 0 < SCALE <= 1 holds true. it's giving 🛟lifeguard energy🛟
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. It's the workspace for the algorithm. Now listen carefully because this matters: the workspace needs to be queried before running the computation. You do the query by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. don't skip the vibe check 🌈
INFO — INFO is INTEGER. here's the whole rundown:

On input:
  == -1 : Perform a workspace query
  <> -1 : normal operation

On exit, workspace query:
  < 0 :  if INFO == -i, the i-Th argument had an illegal value
  >= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:
  == 0:  successful exit
  < 0:  if INFO == -i, the i-Th argument had an illegal value
  > 0:  The equation is not solved correctly. One of the arising inner
        system got singular.

fr fr read your INFO on the way out. INFO > 0 means the equation is not solved correctly because one of the arising inner system got singular. that's the 💀 moment, don't ignore it.

Author — Martin Koehler, MPI Magdeburg 🫶

Date — October 2025 📅

Definition at line 1268 of file tgcsylv.c.

💖 `mepack_double_tgcsylv_level2_local_copy_96` 💖

void mepack_double_tgcsylv_level2_local_copy_96 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK,
    int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=96). ok the name is a whole paragraph but we move ✨

🎀 Purpose 🎀

mepack_double_tgcsylv_level2_local_copy_96 solves a generalized coupled Sylvester equation of the following form:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. iykyk 💅

🌸 Remarks 🌸

The function is a wrapper for dla_tgcsylv_l2_local_copy_96. it's giving delegation, we love a middle manager 🫶

🦋 See also 🦋

dla_tgcsylv_l2_local_copy_96

✨ Parameters ✨

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. 🔥
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. 🔥
M — M is INTEGER. The order of the matrices A and C. M >= 0. 📏
N — N is INTEGER. The order of the matrices B and D. N >= 0. 📏
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. 👑
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 🌸
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 matrix C must be upper triangular. 🦋
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 💜
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N). ⭐
E — E is DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 😭💖
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M). 🌈
F — F is DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. 🍓
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (again, that's LDE exactly as written in the source, we keep it character for character, no notes 🙈)
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. 🛟
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. 🧚
INFO — INFO is INTEGER.

On input:
  == -1 : Perform a workspace query
  <> -1 : normal operation

On exit, workspace query:
  < 0 :  if INFO == -i, the i-Th argument had an illegal value
  >= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:
  == 0:  successful exit
  < 0:  if INFO == -i, the i-Th argument had an illegal value
  > 0:  The equation is not solved correctly. One of the arising inner
        system got singular.

Author — Martin Koehler, MPI Magdeburg 🫶

Date — October 2025 📅

Definition at line 1478 of file tgcsylv.c.

💖 `mepack_double_tgcsylv_level2_reorder` 💖

void mepack_double_tgcsylv_level2_reorder (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 *
    E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int *
    INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Reordered variant). yes bestie, the reordered variant, we're in the remix era 💅✨

🎀 Purpose 🎀

mepack_double_tgcsylv_level2_reorder solves a generalized coupled Sylvester equation of the following form:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. 👑

🌸 Remarks 🌸

The function is a wrapper for dla_tgcsylv_l2_reorder. 🫶

🦋 See also 🦋

dla_tgcsylv_l2_reorder

✨ Parameters ✨

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB
TRANSB — a String that tells the routine which form of the system of equations to use with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — DOUBLE PRECISION, allowed values: +/-1. Tells you the sign between in the first equation. 💅
SGN2 — DOUBLE PRECISION, allowed values: +/-1. Tells you the sign between in the second equation. 🎀
M — INTEGER. The order of the matrices A and C. M >= 0.
N — INTEGER. The order of the matrices B and D. N >= 0.
A — DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. 🔺
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — DOUBLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular, then the matrix B must be upper triangular.
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — DOUBLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — DOUBLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular, then the matrix D must be upper triangular.
LDD — INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1), as selected by TRANSA, TRANSB, and SGN1/SGN2. The right hand side E and the solution R are M-by-N matrices. ✨
LDE — INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1), as selected by TRANSA, TRANSB, and SGN1/SGN2. The right hand side F and the solution L are M-by-N matrices.
LDF — INTEGER. The leading dimension of the array F. LDE >= max(1,M). (ngl bestie, the page really does say LDE on this line — we are keeping it character for character 🙈)
SCALE — DOUBLE PRECISION. A scaling factor to prevent overflow in the result. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. You have to query the workspace before running the computation — the query happens by calling the subroutine with INFO == -1 on input, and the required workspace comes back to you in INFO.
INFO — INTEGER. The whole vibe check of the call:

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit ✨
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular. 💀

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 636 of file tgcsylv.c.

mepack_double_tgcsylv_level2_unopt

void mepack_double_tgcsylv_level2_unopt (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Unoptimized variant) 🦋

Purpose

mepack_double_tgcsylv_level2_unopt solves a generalized coupled Sylvester equation of the following form

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK.

Remarks

The function is a wrapper for dla_tgcsylv_l2_unopt.

Parameters

TRANSA — String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. 💅
SGN2 — DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. 🎀
M — INTEGER. The order of the matrices A and C. M >= 0.
N — INTEGER. The order of the matrices B and D. N >= 0.
A — DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — DOUBLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular, then the matrix B must be upper triangular.
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — DOUBLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — DOUBLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular, then the matrix D must be upper triangular.
LDD — INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1), as selected by TRANSA, TRANSB, and SGN1/SGN2. The right hand side E and the solution R are M-by-N matrices.
LDE — INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1), as selected by TRANSA, TRANSB, and SGN1/SGN2. The right hand side F and the solution L are M-by-N matrices.
LDF — INTEGER. The leading dimension of the array F. LDE >= max(1,M). (same LDE situation, same energy, we're not touching it 🫶)
SCALE — DOUBLE PRECISION. A scaling factor to prevent overflow in the result. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to be queried before running the computation — you do that by calling the subroutine with INFO == -1 on input, and the required workspace is then returned in INFO.
INFO — INTEGER. The receipts:

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit ✨
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 425 of file tgcsylv.c.

mepack_double_tgcsylv_level3

void mepack_double_tgcsylv_level3 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation. 👑

Purpose

mepack_double_tgcsylv_level3 solves a generalized coupled Sylvester equation of the following form

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

…where A is an M-by-M quasi upper triangular matrix, C is an M-by-M upper triangular matrix, and B and D are N-by-N upper triangular matrices. And here's the tea 🫖 — either B or D gets to be quasi upper triangular as well, like one of them is the extra one, no cap. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. That's the whole pipeline bestie ✨

🎀 Remarks 🎀

The function is a wrapper for dla_tgcsylv_l3. That's the entire remark. Short, sweet, iconic. 💅

🦋 See also 🦋

dla_tgcsylv_l3

🌸 Parameters 🌸

TRANSA — String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — INTEGER. The order of the matrices A and C. M >= 0.
N — INTEGER. The order of the matrices B and D. N >= 0.
A — DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — DOUBLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — DOUBLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — DOUBLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE — INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — INTEGER. The leading dimension of the array F. LDE >= max(1,M). (yes bestie, it really says LDE there — we are reading it exactly as written, not a single character changed 💀)
SCALE — DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INTEGER.
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

👑 Author 👑

Martin Koehler, MPI Magdeburg

🗓️ Date 🗓️

October 2025

📌 Definition 📌

Definition at line 214 of file tgcsylv.c.

💖 `mepack_double_tgcsylv_level3_2stage` 💖

void mepack_double_tgcsylv_level3_2stage (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 *
    E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int *
    INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm with sub-blocking for the generalized coupled Sylvester equation. 🌈

🍓 Purpose 🍓

mepack_double_tgcsylv_level3_2stage solves a generalized coupled Sylvester equation of the following form, bestie:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

…where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. And also either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. Same energy as the level 3 version, just with the sub-blocking glow-up ✨

🎀 Remarks 🎀

The function is a wrapper for dla_tgcsylv_l3_2s. 💅

🦋 See also 🦋

dla_tgcsylv_l3_2s

🌸 Parameters 🌸

TRANSA — String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — INTEGER. The order of the matrices A and C. M >= 0.
N — INTEGER. The order of the matrices B and D. N >= 0.
A — DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — DOUBLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — DOUBLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — DOUBLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE — INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — INTEGER. The leading dimension of the array F. LDE >= max(1,M). (again — LDE, verbatim, we are not touching it 🙈)
SCALE — DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INTEGER.
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

👑 Author 👑

Martin Koehler, MPI Magdeburg

🗓️ Date 🗓️

October 2025

📌 Definition 📌

Definition at line 636 of file tgcsylv.c.

💖 `void mepack_double_tgcsylv_level3_unopt (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)` 💖

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation — but make it the Unoptimized variant bestie, no glow-up, just vibes 🦋

🌸 Purpose 🌸

mepack_double_tgcsylv_level3_unopt solves a generalized coupled Sylvester equation that looks like this:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

okay so here's the tea ☕ — A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix, and B and D are N-by-N upper triangular matrices. And either B or D can be quasi upper triangular as well, flexible queen 💅 The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. iykyk ✨

🎀 Remarks 🎀

The function is a wrapper for dla_tgcsylv_l3_unopt

🦋 See also 🦋

dla_tgcsylv_l3_unopt

💜 Parameters 💜

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. 👑
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. ⚠️ careful bestie
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. ⚠️ same energy, flip the names
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 🫶 glow up moment
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. ✨
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. 🌈
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. 🔍
INFO — INFO is INTEGER
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular. 💀

👑 Author 👑

Martin Koehler, MPI Magdeburg

⭐ Date ⭐

October 2025

🍓 Definition 🍓

Definition at line 425 of file tgcsylv.c.

💖 `void mepack_double_tgcsylv_recursive (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)` 💖

Recursive blocking Algorithm for the generalized coupled Sylvester equation. bestie it recurses, it blocks, it solves 🧚✨

🌸 Purpose 🌸

mepack_double_tgcsylv_recursive solves a generalized coupled Sylvester equation of the following form:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

🎀 Remarks 🎀

The function is a wrapper for dla_tgcsylv_recursive

🦋 See also 🦋

dla_tgcsylv_recursive

💜 Parameters 💜

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. 👑
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. ⚠️
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. ⚠️
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is DOUBLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 🫶
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is DOUBLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. ✨
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. 🌈
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. 🔍
INFO — INFO is INTEGER
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation

On exit, when it's doing a workspace query:

< 0 — if INFO == -i, the i-Th argument had an illegal value 🙈
>= 0 — the value of INFO is the required number of elements in the workspace ✨

On exit, during normal operation:

== 0 — successful exit, we ate 💅
< 0 — if INFO == -i, the i-Th argument had an illegal value 😭
> 0 — the equation is not solved correctly. One of the arising inner systems got singular 💀

Author 🫶

Martin Koehler, MPI Magdeburg

Date 🎀

October 2025

Definition at line 214 of file tgcsylv.c.

`void mepack_double_tgsylv_dag` 🌈

void mepack_double_tgsylv_dag (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 *
    SCALE, double * WORK, int * INFO)

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester equation with DAG based parallelization. bestie this one is out here parallelizing, it's giving main character energy fr fr 🔥

Purpose:

mepack_double_tgsylv_dag solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for dla_tgsylv_dag. 💜

See also

dla_tgsylv_dag

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1: Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver. ⚠️ like, do not ignore this one bestie.
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. ✨
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

Author 🫶

Martin Koehler, MPI Magdeburg

Date 🎀

October 2025

Definition at line 195 of file tgsylv.c.

`void mepack_double_tgsylv_gardiner_laub` 🌸

void mepack_double_tgsylv_gardiner_laub (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 * SCALE, double * WORK, int * INFO)

GARDINER-Laub Algorithm for the generalized Sylvester equation. okay so this one is named after Gardiner and Laub, iconic duo energy fr 💅

Purpose:

mepack_double_tgsylv_gardiner_laub solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for dla_tgsylv_gardiner_laub. 💜

See also

dla_tgsylv_gardiner_laub

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1: Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver. 🚨 yes this again, and yes it still matters.
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. ✨
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit 💖
< 0: if INFO == -i, the i-Th argument had an illegal value 😭
> 0: The equation is not solved correctly. One of the arising inner system got singular. 💀

Author: Martin Koehler, MPI Magdeburg Date: October 2025 Definition at line 1941 of file tgsylv.c.

👑 `mepack_double_tgsylv_level2` 👑

void mepack_double_tgsylv_level2 (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 *
    SCALE, double * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Classical level 2 variant)

Purpose:

mepack_double_tgsylv_level2 solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for dla_tgsylv_l2.

See also

dla_tgsylv_l2

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1: Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver.
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER.

On input:

== -1: Perform a workspace query
<> -1: normal operation

On exit, workspace query:

< 0: if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

Author: Martin Koehler, MPI Magdeburg Date: October 2025 Definition at line 1359 of file tgsylv.c.

🦋 `mepack_double_tgsylv_level2_colwise` 🦋

void mepack_double_tgsylv_level2_colwise (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 * SCALE, double * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Column-by-column variant)

Purpose:

mepack_double_tgsylv_level2_colwise solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for dla_tgsylv_l2_colwise.

See also

dla_tgsylv_l2_colwise

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1: Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver.
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER.

On input:

== -1: Perform a workspace query
<> -1: normal operation

On exit, workspace query:

< 0: if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

                      == 0:  successful exit
                      < 0:  if INFO == -i, the i-Th argument had an illegal value
                      > 0:  The equation is not solved correctly. One of the arising inner
                            system got singular.

Author — Martin Koehler, MPI Magdeburg 💖

Date — October 2025 ✨

Definition at line 1747 of file tgsylv.c.

🌸 `mepack_double_tgsylv_level2_local_copy` 🌸

void mepack_double_tgsylv_level2_local_copy (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 * SCALE, double * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation — and this one is the Local copies, unaligned flavor, bestie 💅

Purpose:

mepack_double_tgsylv_level2_local_copy solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore, either B or D can be quasi upper triangular as well 👀. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK 🦋

Remarks — bestie this one is literally just a wrapper for dla_tgsylv_l2_local_copy, no cap 🙈

See also — go peek at dla_tgsylv_l2_local_copy 👑

Parameters

TRANSA — TRANSA is String. It specifies the form of the system of equations with respect to A and C:

== 'N':  op1(A) = A, op1(C) = C (No transpose for A and C)
== 'T':  op1(A) = A**T, op1(C) = C **T (Transpose A and C)

TRANSB — TRANSB is String. It specifies the form of the system of equations with respect to B and D:

== 'N':  op2(B) = B, op2(D) = D (No transpose for B and D)
== 'T':  op2(B) = B**T, op2(D) = D **T (Transpose B and D)

SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. It specifies the sign between the two parts of the Sylvester equation 💫

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

M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular 🎀
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular, the matrix B must be upper triangular 👀
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 matrix C must be upper triangular 🎀
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular, the matrix D must be upper triangular 👀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X holds the right hand side Y. On output, the matrix X holds the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices ✨
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. It's the scaling factor that keeps the result from overflowing 🫶. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems couldn't be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is not solved correctly and in that case you have to use another solver, fr fr 😭
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to be queried before running the computation. The query is performed by calling the subroutine with INFO == -1 on input, and the required workspace is then returned in INFO 💅
INFO — INFO is INTEGER.

On input:

  == -1 : Perform a workspace query
  <> -1 : normal operation

On exit, workspace query:

  < 0 :  if INFO == -i, the i-Th argument had an illegal value
  >= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

  == 0:  successful exit
  < 0:  if INFO == -i, the i-Th argument had an illegal value
  > 0:  The equation is not solved correctly. One of the arising inner
        system got singular.

Author — Martin Koehler, MPI Magdeburg 💖

Date — October 2025 ✨

Definition at line 971 of file tgsylv.c.

🦋 `mepack_double_tgsylv_level2_local_copy_128` 🦋

void mepack_double_tgsylv_level2_local_copy_128 (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 * SCALE, double * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation — this is the Local copies, M,N<=128 version, and she is giving tiny-matrix main character energy 👑💅

Purpose:

mepack_double_tgsylv_level2_local_copy_128 solves a generalized Sylvester equation of the following forms

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

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

Remarks — once again, she's just a wrapper, this time for dla_tgsylv_l2_local_copy_128 🙈

See also — the icon herself, dla_tgsylv_l2_local_copy_128 ✨

Parameters

TRANSA — TRANSA is String. It specifies the form of the system of equations with respect to A and C:

== 'N':  op1(A) = A, op1(C) = C (No transpose for A and C)
== 'T':  op1(A) = A**T, op1(C) = C **T (Transpose A and C)

TRANSB — TRANSB is String. It specifies the form of the system of equations with respect to B and D:

== 'N':  op2(B) = B, op2(D) = D (No transpose for B and D)
== 'T':  op2(B) = B**T, op2(D) = D **T (Transpose B and D)

SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. It specifies the sign between the two parts of the Sylvester equation 💫

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

M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular 🎀
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular, the matrix B must be upper triangular 👀
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 matrix C must be upper triangular 🎀
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular, the matrix D must be upper triangular 👀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X holds the right hand side Y. On output, the matrix X holds the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices ✨
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. It's the scaling factor that keeps the result from overflowing 🫶. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems couldn't be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is not solved correctly and in that case you have to use another solver, fr fr 😭
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to be queried before running the computation. The query is performed by calling the subroutine with INFO == -1 on input, and the required workspace is then returned in INFO 💅
INFO — INFO is INTEGER.

On input:

  == -1 : Perform a workspace query
  <> -1 : normal operation

On exit, workspace query:

  < 0 :  if INFO == -i, the i-Th argument had an illegal value
  >= 0:  The value of INFO is the required number of elements in the workspace.

== 0: successful exit ✨ literally the dream
< 0: if INFO == -i, the i-Th argument had an illegal value 😭 somebody handed me a bad argument
> 0: the equation is not solved correctly. One of the arising inner system got singular 💀

Author — Martin Koehler, MPI Magdeburg

Date — October 2025

Definition — at line 777 of file tgsylv.c.

`mepack_double_tgsylv_level2_local_copy_32`

void mepack_double_tgsylv_level2_local_copy_32 (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 * SCALE, double * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Local copies, M,N<=32) 🦋

Purpose:

mepack_double_tgsylv_level2_local_copy_32 solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for dla_tgsylv_l2_local_copy_32. 💅

See also

dla_tgsylv_l2_local_copy_32

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 👀
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 🫶
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices. ✨
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver. 🚨
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. 💅
INFO — INFO is INTEGER
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

Author — Martin Koehler, MPI Magdeburg

Date — October 2025

Definition — at line 195 of file tgsylv.c.

`mepack_double_tgsylv_level2_local_copy_64`

void mepack_double_tgsylv_level2_local_copy_64 (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 * SCALE, double * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Local copies, M,N<=64) 🎀

Purpose:

mepack_double_tgsylv_level2_local_copy_32 solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for dla_tgsylv_l2_local_copy_64. ✨

See also

dla_tgsylv_l2_local_copy_64

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 👑
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 🦋
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices. 💖
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver. 🚨
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. 💜
INFO — INFO is INTEGER
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit, we love to see it 💅
< 0: if INFO == -i, the i-Th argument had an illegal value (rude, but okay)
> 0: The equation is not solved correctly. One of the arising inner system got singular. 😭

Author ✨

Martin Koehler, MPI Magdeburg

Date 🎀

October 2025

Definition at line 389 of file tgsylv.c.

💖 `void mepack_double_tgsylv_level2_reorder (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 * SCALE, double * WORK, int * INFO)`

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Reordered variant) 🌸

Purpose 💜

mepack_double_tgsylv_level2_reorder solves a generalized Sylvester equation of the following forms

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

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

Remarks 🌸

This function is a wrapper for dla_tgsylv_l2_reorder. (iconic behavior honestly 👑)

Parameters 🎀

TRANSA

TRANSA is String Specifies the form of the system of equations with respect to A and C:

== 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
== 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)

TRANSB

TRANSB is String Specifies the form of the system of equations with respect to B and D:

== 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
== 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)

SGN

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

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

M

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

N

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

A

A is DOUBLE PRECISION array, dimension (LDA,M) The matrix A must be (quasi-) upper triangular.

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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.

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 matrix C must be upper triangular.

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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.

LDD

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

X

X is DOUBLE PRECISION array, dimension (LDX,N) On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices.

LDX

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

SCALE

SCALE is DOUBLE PRECISION SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver. 🚨

WORK

WORK is DOUBLE PRECISION array, dimension LDWORK Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.

INFO

INFO is INTEGER

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:
  == 0:  successful exit
  < 0:  if INFO == -i, the i-Th argument had an illegal value
  > 0:  The equation is not solved correctly. One of the arising inner
        system got singular.

okay so decode the vibe check: 0 = we ate, no notes 💅. A negative number means INFO == -i and argument number i was illegal (rude of it). A positive number means the equation did NOT get solved correctly because one of the arising inner systems came out singular — that's a big yikes, not a you problem. 😭

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 1165 of file tgsylv.c.

`mepack_double_tgsylv_level2_rowwise` 🦋

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Row-by-Row variant)

Purpose:

bestie, mepack_double_tgsylv_level2_rowwise solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for dla_tgsylv_l2_rowwise.

See also

dla_tgsylv_l2_rowwise

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:

== 'N':  op1(A) = A, op1(C) = C (No transpose for A and C)
== 'T':  op1(A) = A**T, op1(C) = C **T (Transpose A and C)

TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:

== 'N':  op2(B) = B, op2(D) = D (No transpose for B and D)
== 'T':  op2(B) = B**T, op2(D) = D **T (Transpose B and D)

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

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

M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver.
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 :  if INFO == -i, the i-Th argument had an illegal value
>= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0:  successful exit
< 0:  if INFO == -i, the i-Th argument had an illegal value
> 0:  The equation is not solved correctly. One of the arising inner
      system got singular.

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 1553 of file tgsylv.c.

`mepack_double_tgsylv_level3` 👑

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester equation.

Purpose:

mepack_double_tgsylv_level3 solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for dla_tgsylv_l3.

See also

dla_tgsylv_l3

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:

== 'N':  op1(A) = A, op1(C) = C (No transpose for A and C)
== 'T':  op1(A) = A**T, op1(C) = C **T (Transpose A and C)

TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:

== 'N':  op2(B) = B, op2(D) = D (No transpose for B and D)
== 'T':  op2(B) = B**T, op2(D) = D **T (Transpose B and D)

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

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

M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver.
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 :  if INFO == -i, the i-Th argument had an illegal value
>= 0:  The value of INFO is the required number of elements in the workspace.

heads up bestie, the page keeps going — there's more of this INFO block coming in the next part, don't close the tab 💜

On exit, normal operation:

== 0: slayed, successful exit 💖
< 0: if INFO == -i, then the i-th argument was giving illegal value energy (not it) 😭
> 0: the equation did not get solved correctly — one of the inner systems it spawned came out singular 💀

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition

At line 195 of file tgsylv.c.

`void mepack_double_tgsylv_level3_2stage (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 * SCALE, double * WORK, int * INFO)`

okay bestie, this one is the Level-3 Bartels-Stewart Algorithm with sub-blocking for the generalized Sylvester equation 🎀

Purpose

mepack_double_tgsylv_level3_2stage solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. ✨

Remarks

This function is literally just a wrapper for dla_tgsylv_l3_2s — it's giving middle-manager, but make it iconic 🫶

Parameters

TRANSA — TRANSA is String. It says what form the system of equations takes with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (no transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (transpose A and C)
TRANSB — TRANSB is String. It says what form the system of equations takes with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (no transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (transpose B and D)
SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. It sets the sign between the two parts of the Sylvester equation.
- = 1: solve Equation (1)
- == -1: solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular, no cap.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 👑
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices. ✨
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver.

bestie listen 💀 if SCALE .NE. 1 you did not get a correct solve, so you gotta go grab a different solver. that's not a vibe, that's a fact.

WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. 🎀
INFO — INFO is INTEGER.

On input:

== -1: perform a workspace query
<> -1: normal operation

On exit, workspace query:

< 0: if INFO == -i, the i-th argument had an illegal value
>= 0: the value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit 💖
< 0: if INFO == -i, the i-th argument had an illegal value
> 0: the equation is not solved correctly. One of the arising inner system got singular.

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition

At line 777 of file tgsylv.c.

`void mepack_double_tgsylv_level3_colwise (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 * SCALE, double * WORK, int * INFO)`

this is the Level-3 Bartels-Stewart Algorithm for the generalized Sylvester equation but make it Column-by-Column 🦋 (the variant name said it first)

Purpose

mepack_double_tgsylv_level3_colwise solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. ✨

Remarks

This function is a wrapper for dla_tgsylv_l3_colwise. periodt 💅

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1: solve Equation (1)
- == -1: solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 👑
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices. 🌸
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver.

fr fr, if SCALE .NE. 1 the solve did not land — go find another solver, bestie 😭

WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. 🎀
INFO — INFO is INTEGER.

On input:

== -1: perform a workspace query
<> -1: normal operation

On exit, workspace query:

< 0: if INFO == -i, the i-th argument had an illegal value
>= 0: the value of INFO is the required number of elements in the workspace.

On exit, normal operation:
- == 0: successful exit, we ate and left no crumbs 💅
- < 0: if INFO == -i, then the i-th argument had an illegal value — so like, you passed something cursed bestie 😭
- > 0: the equation is not solved correctly. One of the arising inner systems got singular 💀

👑 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

📍 Definition

Definition at line 583 of file tgsylv.c.

✨ `void mepack_double_tgsylv_level3_rowwise` ✨

void mepack_double_tgsylv_level3_rowwise (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 * SCALE, double * WORK, int * INFO)

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester equation (Row-by-row variant) 🫶

Purpose:

mepack_double_tgsylv_level3_rowwise solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for dla_tgsylv_l3_rowwise.

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 👀
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 👀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N).
- On input, the matrix X contains the right hand side Y.
- On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN.
- Right hand side Y and the solution X are M-by-N matrices.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver. 🚨
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. ✨
INFO — INFO is INTEGER.
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular. 💀

👑 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

📍 Definition

Definition at line 389 of file tgsylv.c.

✨ `void mepack_double_tgsylv_recursive` ✨

void mepack_double_tgsylv_recursive (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 * SCALE, double * WORK, int * INFO)

Recursive blocking Algorithm for the generalized Sylvester equation. 🌀

Purpose:

mepack_double_tgsylv_recursive solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for dla_tgsylv_recursive.

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is DOUBLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 👀
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 👀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is DOUBLE PRECISION array, dimension (LDX,N).
- On input, the matrix X contains the right hand side Y.
- On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN.
- Right hand side Y and the solution X are M-by-N matrices.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is DOUBLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver. 🚨
WORK — WORK is DOUBLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. ✨
INFO — INFO is INTEGER.
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.

On exit, when we're in normal operation mode (aka not a workspace query, bestie, just vibes):

== 0:  successful exit
< 0:  if INFO == -i, the i-Th argument had an illegal value
> 0:  The equation is not solved correctly. One of the arising inner
      system got singular.

Author 🫶 Martin Koehler, MPI Magdeburg

Date 🌸 October 2025

Definition at line 195 of file tgsylv.c.

💫 `mepack_single_tgcsylv_dag`

void mepack_single_tgcsylv_dag (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 * E, int LDE, float *
    F, int LDF, float * SCALE, float * WORK, int * INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation with DAG scheduling. ✨

Purpose:

mepack_single_tgcsylv_dag solves a generalized coupled Sylvester equation of the following form

   op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
   op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

Remarks

The function is a wrapper for sla_tgcsylv_dag 🫶

See also

sla_tgcsylv_dag

Parameters

TRANSA — TRANSA is String
- Specifies the form of the system of equations with respect to A and C:
  - == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
  - == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String
- Specifies the form of the system of equations with respect to B and D:
  - == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
  - == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1
- Specifies the sign between in the first equation.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1
- Specifies the sign between in the second equation.
M — M is INTEGER
- The order of the matrices A and C. M >= 0.
N — N is INTEGER
- The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M)
- The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER
- The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N)
- On input, the matrix E contains the right hand side E.
- On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2.
- Right hand side E and the solution R are M-by-N matrices.
LDE — LDE is INTEGER
- The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N)
- On input, the matrix F contains the right hand side F.
- On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2.
- Right hand side F and the solution L are M-by-N matrices.
LDF — LDF is INTEGER
- The leading dimension of the array F. LDE >= max(1,M).

💀 bestie, no cap, the page literally says LDE >= max(1,M) in the LDF description — that's what's written, we're just reading it out loud, we do not make the rules 🙈

SCALE — SCALE is SINGLE PRECISION
- SCALE is a scaling factor to prevent the overflow in the result.
- If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is SINGLE PRECISION array, dimension LDWORK
- Workspace for the algorithm.
- The workspace needs to queried before the running the computation.
- The query is performed by calling the subroutine with INFO == -1 on input.
- The required workspace is then returned in INFO.
INFO — INFO is INTEGER
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

Author 🫶 Martin Koehler, MPI Magdeburg

Date 🌸 October 2025

Definition at line 425 of file tgcsylv.c.

🔥 `mepack_single_tgcsylv_dual_dag`

void mepack_single_tgcsylv_dual_dag (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 * E, int
    LDE, float * F, int LDF, float * SCALE, float * WORK, int * INFO)

OpenMP4 - DAG Algorithm for the dual generalized coupled Sylvester equation. 👑

Purpose:

mepack_single_tgcsylv_dual_dag solves a generalized coupled Sylvester equation of the following form

   op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
   SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

The equation (1) is the dual to the generalized coupled Sylvester equation

   op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
   op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

       | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
 Z X = |                                           |*|       | = |       |
       | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

          | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
 Z**T X = |                                             |*|       | = |       |
          | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2). 🧚

Remarks

This function is a wrapper for sla_tgcsylv_dual_dag. 🫶

See also

sla_tgcsylv_dual_dag

Parameters

TRANSA — TRANSA is CHARACTER(1)
- Specifies the form of the system of equations with respect to A and C:
  - == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
  - == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is CHARACTER(1)
- Specifies the form of the system of equations with respect to B and D:
  - == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
  - == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1
- Specifies the sign between in the first equation.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1
- Specifies the sign between in the second equation.
M — M is INTEGER
- The order of the matrices A and C. M >= 0.
N — N is INTEGER
- The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M)
- The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER
- The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N)
- On input, the matrix E contains the right hand side E.
- On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2.
- Right hand side E and the solution R are M-by-N matrices.
LDE — LDE is INTEGER. It's the leading dimension of the array E. You need LDE >= max(1,M) or it's not giving. 💅
F — F is a SINGLE PRECISION array with dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. 🦋
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M).

bestie, yes it literally says LDE here and not LDF. We're just reading the manpage, not fixing it. 💀

SCALE — SCALE is SINGLE PRECISION. It's a scaling factor to prevent overflow in the result. If INFO == 0 then SCALE is 1.0D0, otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. ✨
WORK — WORK is a SINGLE PRECISION array with dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory. 🛠️
INFO — INFO is INTEGER. Here's the whole situation:
- On input:
 - == -1 : Perform a workspace query ( not recommended in the C interface)
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

Author — Martin Koehler, MPI Magdeburg

Date — October 2025

Definition at line 459 of file tgcsylv_dual.c.

`mepack_single_tgcsylv_dual_level2`

   void mepack_single_tgcsylv_dual_level2 (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 * E, int
       LDE, float * F, int LDF, float * SCALE, float * WORK, int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation. 🔥

Purpose:

mepack_single_tgcsylv_dual_level2 solves a generalized coupled Sylvester equation of the following form

   op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
   SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix, and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by DGGES from LAPACK. 💅

The equation (1) is the dual to the generalized coupled Sylvester equation

   op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
   op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

                kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
         Z X = |                                           |*|       | = |       |
               | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

                  | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
         Z**T X = |                                             |*|       | = |       |
                  | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2).

Remarks:

This function is a wrapper for sla_tgcsylv_dual_l2.

See also:

sla_tgcsylv_dual_l2

Parameters:

TRANSA —
TRANSA — CHARACTER(1) ✨ tells you what form the system of equations takes with respect to A and C, bestie:
- == 'N': op1(A) = A, op1(C) = C (no transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (transpose A and C)
TRANSB — CHARACTER(1) 💫 same energy, but for B and D:
- == 'N': op2(B) = B, op2(D) = D (no transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (transpose B and D)
SGN1 — SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. 🎀
SGN2 — SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. 🎀
M — INTEGER. The order of the matrices A and C. M >= 0.
N — INTEGER. The order of the matrices B and D. N >= 0.
A — SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. 👑
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 🫶
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular. ✨
LDC — INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 🫶
LDD — INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 💖
LDE — INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. 💖
LDF — INTEGER. The leading dimension of the array F. LDE >= max(1,M). (yes bestie, the original literally says LDE here, we do not fix it, we report it 🙈)
SCALE — SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. 🧚
WORK — SINGLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory. 🌸
INFO — INTEGER. The whole vibe check, right here:
- On input:
 - == -1 : Perform a workspace query ( not recommended in the C interface)
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit 🎉
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular. 💀

💜 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

📍 Definition

At line 1832 of file tgcsylv_dual.c.

void mepack_single_tgcsylv_dual_level2_local_copy_128 (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 * E, int LDE, float * F, int LDF, float * SCALE, float * WORK, int
    * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation ( Local Copies, M,N <= 128 ) 🦋

✨ Purpose

mepack_single_tgcsylv_dual_level2_local_copy_128 solves a generalized coupled Sylvester equation of the following form

op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

The equation (1) is the dual to the generalized coupled Sylvester equation

op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

       | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
 Z X = |                                           |*|       | = |       |
       | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

          | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
 Z**T X = |                                             |*|       | = |       |
          | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2). 🌀

🌈 Remarks

This function is a wrapper for sla_tgcsylv_dual_l2_local_copy_128. iykyk 💅

👀 See also

sla_tgcsylv_dual_l2_local_copy_128

🎀 Parameters

TRANSA — CHARACTER(1) ✨ Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — CHARACTER(1) 💫 Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — INTEGER. The order of the matrices A and C. M >= 0.
N — INTEGER. The order of the matrices B and D. N >= 0.
A — SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 🫶
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 🫶
LDD — INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 💖
LDE — INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. 💖
LDF — INTEGER. The leading dimension of the array F. LDE >= max(1,M). (again, that's the original's LDE, not a typo of mine, we simply report 🙈)
SCALE — SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. 🧚
WORK — SINGLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory. 🌸
INFO — INTEGER. Here we go again:
- On input:
 - == -1 : Perform a workspace query ( not recommended in the C interface)
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
On exit, normal operation:
- == 0: successful exit 🎉 she did it, we're so proud
- < 0: if INFO == -i, the i-Th argument had an illegal value 🙈
- > 0: The equation is not solved correctly. One of the arising inner system got singular. 💀 not the singular inner system

👑 Author

Martin Koehler, MPI Magdeburg

🗓️ Date

October 2025

📍 Definition

at line 2752 of file tgcsylv_dual.c.

🦋 `mepack_single_tgcsylv_dual_level2_local_copy_32`

void mepack_single_tgcsylv_dual_level2_local_copy_32 (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 * E, int LDE, float * F, int LDF, float * SCALE, float * WORK, int
    * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation ( Local Copies, M,N <= 32 )

bestie. Look at that name. It's giving "I memorized the whole algorithm and also I'm not afraid to say it out loud." 💅

✨ Purpose

mepack_single_tgcsylv_dual_level2_local_copy_32 solves a generalized coupled Sylvester equation of the following form

op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

The equation (1) is the dual to the generalized coupled Sylvester equation

op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

        | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
  Z X = |                                           |*|       | = |       |
        | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

           | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
  Z**T X = |                                             |*|       | = |       |
           | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2).

🧚 lowkey the whole Kronecker thing is the vibe check of this function. She said "let me re-derive it in block form" and then did. no cap.

🌸 Remarks

This function is a wrapper for sla_tgcsylv_dual_l2_local_copy_32.

🔭 See also

sla_tgcsylv_dual_l2_local_copy_32

🎀 Parameters

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M).

😭 yes bestie, it literally says LDE in the LDF spot. That's what the page says. We do not editorialize, we report. 🫶

SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is SINGLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory.
INFO — INFO is INTEGER
- On input:
 - == -1 : Perform a workspace query ( not recommended in the C interface)
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

👑 Author

Martin Koehler, MPI Magdeburg

🗓️ Date

October 2025

📍 Definition

at line 2062 of file tgcsylv_dual.c.

🦋 `mepack_single_tgcsylv_dual_level2_local_copy_64`

void mepack_single_tgcsylv_dual_level2_local_copy_64 (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 * E, int LDE, float * F, int LDF, float * SCALE, float * WORK, int
    * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation ( Local Copies, M,N <= 64 )

same algorithm, bigger energy. The 32 said "small blocks only," the 64 said "okay but what if we went twice." ⭐

✨ Purpose

mepack_single_tgcsylv_dual_level2_local_copy_64 solves a generalized coupled Sylvester equation of the following form

op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

The equation (1) is the dual to the generalized coupled Sylvester equation

op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

        | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
  Z X = |                                           |*|       | = |       |
        | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

           | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
  Z**T X = |                                             |*|       | = |       |
           | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2).

🍓 yes it's the same derivation as the _32. It's the same equation, bestie. The derivation doesn't change just because the block size did. icon behavior honestly.

🌸 Remarks

This function is a wrapper for sla_tgcsylv_dual_l2_local_copy_64.

🔭 See also

sla_tgcsylv_dual_l2_local_copy_64

🎀 Parameters

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B
B — B is a SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. And here's the little plot twist bestie: if the matrix D is already quasi-upper triangular, then B has to be plain old upper triangular. The way they take turns being the special one 💅
LDB — LDB is INTEGER, aka the leading dimension of the array B. And LDB >= max(1,N). periodt.
C — C is a SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular. no quasi, no games, just triangular 🎀
LDC — LDC is INTEGER, the leading dimension of the array C, and LDC >= max(1,M).
D — D is a SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. Flip side of the earlier rule: if the matrix B is already quasi-upper triangular, then D must be upper triangular. They're matching, it's giving coordinated outfits 💖
LDD — LDD is INTEGER, the leading dimension of the array D. LDD >= max(1,N).
E — E is a SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Both the right hand side E and the solution R are M-by-N matrices. She's a dual citizen, input queen and output queen 👑
LDE — LDE is INTEGER, the leading dimension of the array E. LDE >= max(1,M).
F — F is a SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and solution L are M-by-N matrices. yes she's the other half of the duo 🦋
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M).

okay bestie I need you to know I copied that exactly 🙈 the docs really do say LDE in the LDF description. I don't make the rules, I just deliver them faithfully with my whole chest.

SCALE — SCALE is SINGLE PRECISION. It's the scaling factor that exists purely to stop the result from overflowing (the classic villain of numerical linear algebra 💀). If INFO == 0 then SCALE is 1.0D0, otherwise — if one of the inner systems could not be solved correctly — then 0 < SCALE <= 1 holds true.
WORK — WORK is a SINGLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory. It's the behind-the-scenes bestie doing all the heavy lifting while everyone else takes credit ✨
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query ( not recommended in the C interface)
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

So basically INFO is the group chat narrator: she tells you if you did something illegal, if you need more workspace, if you slayed, or if an inner system went singular on you. read her carefully fr fr 📖

Author 🌸

Martin Koehler, MPI Magdeburg

Date 📅

October 2025

Definition at line 2291 of file tgcsylv_dual.c.

`void mepack_single_tgcsylv_dual_level2_local_copy_96 ( ... )` ✨

void mepack_single_tgcsylv_dual_level2_local_copy_96 (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 * E, int LDE, float * F, int LDF, float * SCALE, float * WORK, int
    * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation ( Local Copies, M,N <= 96 )

Purpose 🎯

mepack_single_tgcsylv_dual_level2_local_copy_96 solves a generalized coupled Sylvester equation of the following form

   op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
   SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

The equation (1) is the dual to the generalized coupled Sylvester equation

   op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
   op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

               | kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
         Z X = |                                           |*|       | = |       |
               | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

                  | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
         Z**T X = |                                             |*|       | = |       |
                  | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2).

Like, the duality here is genuinely iconic — it's giving mirror selfie, it's giving the same equation but transposed, it's giving main character energy 🔥

Remarks 💬

This function is a wrapper for sla_tgcsylv_dual_l2_local_copy_96.

Parameters 🎀

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is a SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — B is a SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — C is a SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — LDC is INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — D is a SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is a SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is a SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M).

still LDE in the LDF blurb, bestie 🫶 I promise I'm not playing games, that's genuinely what the original says.

SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is a SINGLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory.
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query ( not recommended in the C interface)
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

Author 🌸

Martin Koehler, MPI Magdeburg

Date 📅

October 2025

Definition at line 2521 of file tgcsylv_dual.c.

`void mepack_single_tgcsylv_dual_level3 ( ... )` ✨

void mepack_single_tgcsylv_dual_level3 (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 * E, int
    LDE, float * F, int LDF, float * SCALE, float * WORK, int * INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the dual generalized coupled Sylvester equation.

Purpose 🎯

mepack_single_tgcsylv_dual_level3 solves a generalized coupled Sylvester equation of the following form

   op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
   SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

`LDE` 🎀

LDE is INTEGER.

It's the leading dimension of the array E, and the rule is LDE >= max(1,M). That's the whole vibe check, bestie. 💖

`LDF` ✨

LDF is INTEGER.

The leading dimension of the array F, and the constraint is written as LDE >= max(1,M).

ngl that's exactly how it's written in the source — it says LDE in the LDF blurb. not me editing it, i'm just the messenger 💅

`SCALE` 🌸

SCALE is SINGLE PRECISION.

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

so like... it's the safety net that keeps your numbers from absolutely losing it 🫶

`WORK` 🧚

WORK is SINGLE PRECISION array, dimension (MAX(1,LDWORK)).

Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory.

you do not want to be guessing at this one, trust. ✨

`INFO` 💅

INFO is INTEGER.

On input:

== -1: Perform a workspace query ( not recommended in the C interface)
<> -1: normal operation

On exit, workspace query:

< 0: if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

okay so < 0 is "girl, one of your arguments is illegal" in both modes, and > 0 is "the math gave up" — one of the arising inner system got singular 😭. read your INFO fr fr, it's literally telling you what happened 👑

LDE — INTEGER, bestie. The leading dimension of the array E. LDE >= max(1,M). 💅
F — SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. 🦋
LDF — INTEGER. The leading dimension of the array F. LDE >= max(1,M). (yes it says LDE, we are literally quoting the page, no notes 📝)
SCALE — SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. ✨
WORK — SINGLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory. 🔥
INFO — INTEGER. Okay so this one has layers, pay attention:

On input:

== -1 : Perform a workspace query ( not recommended in the C interface)
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular. 😭

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 915 of file tgcsylv_dual.c.

void mepack_single_tgcsylv_dual_recursive 👑

void mepack_single_tgcsylv_dual_recursive (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 * E, int
    LDE, float * F, int LDF, float * SCALE, float * WORK, int * INFO)

Recursive blocking algorithm for the dual generalized coupled Sylvester equation. Bestie. We're going recursive. 🌀

Purpose:

mepack_single_tgcsylv_dual_recursive solves a generalized coupled Sylvester equation of the following form

   op1(A)**T * R  + op1(C)**T * R               = SCALE * E                             (1)
   SGN1 * R * op2(B)**T + SGN2 * L * op2(D)** T = SCALE * F

The equation (1) is the dual to the generalized coupled Sylvester equation

   op1(A) * R + SGN1 * L * op2(B)  = SCALE * E                                          (2)
   op1(C) * R + SGN2 * L * op2(D)  = SCALE * F

The equation (1) is the dual one to equation (2) with respect to the underlying linear system. Let Z be the matrix formed by rewriting (2) into its Kronecker form. This yields

         kron(I, op1(A))   SGN1*kron(op2(B)**T, I) | | Vec R |   | Vec E |
  Z X = |                                           |*|       | = |       |
        | kron(I, op1(C))   SGN2*kron(op2(D)**T, I) | | Vec L |   | Vec F |

Regarding Z**T one obtains

           | kron(I, op1(A)**T )    kron(I, op1(C)**T)   | | Vec R |   | Vec E |
  Z**T X = |                                             |*|       | = |       |
           | SGN1*kron(op2(B), I)   SGN2*kron(op2(D), I) | | Vec L |   | Vec F |

which belongs to the Sylvester equation (1). For this reason the parameters TRANSA and TRANSB are expressed in terms of the Sylvester equation (2). 🧚

Remarks

This function is a wrapper for sla_tgcsylv_dual_recursive. It's giving "I just delegate" energy and honestly? respect. 🫶

See also

sla_tgcsylv_dual_recursive

Parameters

TRANSA — TRANSA is CHARACTER(1). Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is CHARACTER(1). Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. 💜
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. 💜
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. 🎀
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 👀
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 matrix C must be upper triangular. 🎀
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 👀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. ✨
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. ✨
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (again with the LDE, quoting verbatim, not my typo I promise 💀)
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is SINGLE PRECISION array, dimension (MAX(1,LDWORK)). Workspace for the algorithm. The optimal workspace is given by \ref mepack_memory. 🔥
INFO — INFO is INTEGER. Same three-way deal as always:

On input:

== -1 : Perform a workspace query ( not recommended in the C interface)
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 459 of file tgcsylv_dual.c.

void mepack_single_tgcsylv_level2 🌈

void mepack_single_tgcsylv_level2 (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 * E, int LDE, float *
    F, int LDF, float * SCALE, float * WORK, int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation. Say that five times fast, bestie, I dare you. 🗣️💖

Purpose:

mepack_single_tgcsylv_level2 solves a generalized coupled Sylvester equation of the following form

   op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
   op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

Remarks

The function is a wrapper for sla_tgcsylv_l2. 👑

See also

sla_tgcsylv_l2

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. 💜
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. 💜
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. 🎀
LDA
TRANSB — bestie this is a String and it picks what shape the system takes when it comes to B and D:
- == 'N': op2(B) = B, op2(D) = D (no transpose for B and D, they're living their truth as-is)
- == 'T': op2(B) = B**T, op2(D) = D **T (transpose B and D, flip 'em)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. It specifies the sign between in the first equation. That little plus-or-minus is doing SO much heavy lifting fr.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. It specifies the sign between in the second equation. Same energy, second equation. 💅
M — M is INTEGER. The order of the matrices A and C. M >= 0. (Zero is allowed, she's inclusive like that.)
N — N is INTEGER. The order of the matrices B and D. N >= 0. Periodt.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. No exceptions, the vibes demand it. 🦋
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 matrix B must be (quasi-) upper triangular. And here's the tea: if the matrix D is already quasi-upper triangular, the matrix B must be upper triangular. They can't both be out here being quasi, that's not the vibe check.
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 matrix C must be upper triangular. Strictly. Iconic, no notes. ✨
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 matrix D must be (quasi-) upper triangular. And same rule as before, just flipped: if the matrix B is already quasi-upper triangular, the matrix D must be upper triangular. It's giving mutual exclusivity, and honestly? We respect it. 💖
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. So she goes in as the problem and comes out as the answer, main character arc honestly. 👑
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. Same glow-up energy as E, we love a transformation. 🦋
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (Yes bestie, it says LDE here — that's literally what the original says, so we're keeping it exactly as-is, no cap. Don't come for me, come for the source. 😭)
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0, otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. She's the bodyguard keeping your numbers from overflowing into the void. 🫶
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. So basically you gotta ASK her how much space she needs first, like a true diva. And honestly? Deserved. 💅
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 :  if INFO == -i, the i-Th argument had an illegal value
>= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0:  successful exit
< 0:  if INFO == -i, the i-Th argument had an illegal value
> 0:  The equation is not solved correctly. One of the arising inner
      system got singular.

So INFO is the group chat that tells you what went down: negative means somebody handed over an illegal value (an argument said something wrong, we've all been there 🙈), >= 0 after a query means "here's how much workspace I need", and a positive number on a real run means one of the inner systems went singular and the equation didn't get solved correctly. 💀

Author 🌸

Martin Koehler, MPI Magdeburg

Date ⭐

October 2025

Definition 📌

Definition at line 2533 of file tgcsylv.c.

🧚 `void mepack_single_tgcsylv_level2_local_copy_128 (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 * E, int LDE, float * F, int LDF, float * SCALE, float * WORK, int * INFO)` 💜

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=128)

Purpose:

mepack_single_tgcsylv_level2_local_copy_128 solves a generalized coupled Sylvester equation of the following form

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

Remarks 🔥

The function is a wrapper for sla_tgcsylv_l2_local_copy_128

Parameters ✨

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. 💅
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (Again bestie — this is verbatim what the page says, keeping it EXACTLY as written, we do not edit the source, we only serve cunt while quoting it faithfully. 💖)
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 :  if INFO == -i, the i-Th argument had an illegal value
>= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0:  successful exit
< 0:  if INFO == -i, the i-Th argument had an illegal value
> 0:  The equation is not solved correctly. One of the arising inner
      system got singular.

Author 🌈

Martin Koehler, MPI Magdeburg

Date 🎀

October 2025

Definition 📎

Definition at line 2533 of file tgcsylv.c.

TRANSB — a string, and it picks the form of the system of equations for B and D:
- == 'N': op2(B) = B, op2(D) = D (no transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (transpose B and D)
SGN1 — SINGLE PRECISION, allowed values: +/-1. It's the sign hanging out between the two terms in the first equation.
SGN2 — SINGLE PRECISION, allowed values: +/-1. Same deal, but for the second equation.
M — INTEGER. The order of the matrices A and C. So like, M >= 0, no negativity allowed bestie.
N — INTEGER. The order of the matrices B and D. Also N >= 0.
A — SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. And here's the lil plot twist: if the matrix D is already quasi-upper triangular, then B must be plain upper triangular.
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular. No quasi business here, just upper.
LDC — INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. And mirroring the earlier vibe: if B is already quasi-upper triangular, then D must be upper triangular.
LDD — INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — SINGLE PRECISION array, dimension (LDE,N). On input, E is holding the right hand side E. On output, E is holding the solution R of Equation (1), as selected by TRANSA, TRANSB, and SGN1/SGN2. Both the right hand side E and the solution R are M-by-N matrices.
LDE — INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — SINGLE PRECISION array, dimension (LDF,N). On input, F is holding the right hand side F. On output, F is holding the solution L of Equation (1), as selected by TRANSA, TRANSB, and SGN1/SGN2. Both the right hand side F and the solution L are M-by-N matrices.
LDF — INTEGER. The leading dimension of the array F. LDE >= max(1,M). (yeah bestie, the page literally says LDE there — we're not fixing it, we're reporting it 💅)
SCALE — SINGLE PRECISION. It's the scaling factor that stops the result from overflowing. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems couldn't be solved correctly, 0 < SCALE <= 1 holds true.
WORK — SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. Heads up: you gotta query the workspace before running the computation. You do that by calling the subroutine with INFO == -1 on input, and the required workspace comes back to you in INFO. Iconic, honestly.
INFO — INTEGER.

On input:

== -1: perform a workspace query
<> -1: normal operation

On exit, workspace query:

< 0: if INFO == -i, the i-Th argument had an illegal value
>= 0: the value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit 🎉
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: the equation is not solved correctly. One of the arising inner system got singular. 😭 yeah, that one hurts.

Author 🫶

Martin Koehler, MPI Magdeburg

Date 🎀

October 2025

Definition

Definition at line 3374 of file tgcsylv.c.

🌸 `mepack_single_tgcsylv_level2_local_copy_32` 🌸

void mepack_single_tgcsylv_level2_local_copy_32 (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 * E,
    int LDE, float * F, int LDF, float * SCALE, float * WORK, int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=32)

Purpose 💖

mepack_single_tgcsylv_level2_local_copy_32 solves a generalized coupled Sylvester equation of the following form

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix, and B and D are N-by-N upper triangular matrices. And plot twist: furthermore, either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) (or (D,B)) are created by SGGES from LAPACK.

Remarks 🙈

The function is a wrapper for sla_tgcsylv_l2_local_copy_32

Parameters ✨

TRANSA — a string. It specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (no transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (transpose A and C)
TRANSB — a string. It specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (no transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (transpose B and D)
SGN1 — SINGLE PRECISION, allowed values: +/-1. Specifies the sign in between in the first equation.
SGN2 — SINGLE PRECISION, allowed values: +/-1. Specifies the sign in between in the second equation.
M — INTEGER. The order of the matrices A and C. M >= 0.
N — INTEGER. The order of the matrices B and D. N >= 0.
A — SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE — INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — INTEGER. The leading dimension of the array F. LDE >= max(1,M). (still says LDE, still not our problem 🫶)
SCALE — SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INTEGER.

On input:

== -1: Perform a workspace query
<> -1: normal operation

On exit, workspace query:

< 0: if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

Author 🫶

Martin Koehler, MPI Magdeburg

Date 🎀

October 2025

Definition

Definition at line 2744 of file tgcsylv.c.

🦋 `mepack_single_tgcsylv_level2_local_copy_64` 🦋

void mepack_single_tgcsylv_level2_local_copy_64 (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 * E,
    int LDE, float * F, int LDF, float * SCALE, float * WORK, int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=64)

Purpose 💖

mepack_single_tgcsylv_level2_local_copy_64 solves a generalized coupled Sylvester equation of the following form

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

...where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix, and B and D are N-by-N upper triangular matrices. And bestie, plot twist ✨ — either B or D can be quasi upper triangular too. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) (or (D,B)) are created by SGGES from LAPACK. iykyk 💅

🌸 Remarks 🌸

The function is a wrapper for sla_tgcsylv_l2_local_copy_64. She's giving delegation, she's giving girlboss, she is not doing the math herself 😌

🦋 See also 🦋

sla_tgcsylv_l2_local_copy_64 — go say hi to the real one doing the work 🫶

✨ Parameters ✨

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. It's giving "which way does the vibe go" ➕➖
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. Same energy, second equation 💫
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. No exceptions bestie 🙈
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. Read that twice, it's a whole conditional situation 💀
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 matrix C must be upper triangular. Strictly upper triangular, no quasi-ness here, she said what she said ✋
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. The other half of that conditional, love that for them 🎀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. She comes in as one thing and leaves as another — glow up 🌈
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. Same transformation arc, different matrix 💜
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (Yes bestie, the original says LDE here — not me fixing it, that's literally what it says 😭)
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. She's the safety net fr fr 🛟
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. Ask first, then run — that's the rule 💅
INFO — INFO is INTEGER.
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

Bestie, that > 0 case? That's the "one of the inner systems got singular" jump scare. Not a crash, not a bug — just the math saying "nope, can't solve this one" 🙈

👑 Author 👑

Martin Koehler, MPI Magdeburg

📅 Date 📅

October 2025

Definition at line 2954 of file tgcsylv.c.

void mepack_single_tgcsylv_level2_local_copy_96 (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 * E,
    int LDE, float * F, int LDF, float * SCALE, float * WORK, int * INFO)

🌟 Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation (Local copies, M,N<=96) 🌟

💖 Purpose: 💖

mepack_single_tgcsylv_level2_local_copy_96 solves a generalized coupled Sylvester equation of the following form

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. She's the bigger sister of the _64 version, same vibe, more room to breathe ✨

🌸 Remarks 🌸

The function is a wrapper for sla_tgcsylv_l2_local_copy_96. Once again, delegation, queen behavior 👑

🦋 See also 🦋

sla_tgcsylv_l2_local_copy_96 — the actual MVP 🫶

✨ Parameters ✨

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. ➕➖
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. 💫
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. Yes, same conditional as before, she's consistent 💀
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 🎀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 🌈
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. 💜
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (And again, bestie — the original still says LDE. I'm just the messenger 🫠)
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. 🛟
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. Query first, bestie 💅
INFO — INFO is INTEGER.
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

Same warning as always, no cap: > 0 means the equation is not solved correctly because one of the arising inner systems got singular. Not a drill 🔥

👑 Author 👑

Martin Koehler, MPI Magdeburg

📅 Date 📅

October 2025

Definition at line 3164 of file tgcsylv.c.

`mepack_single_tgcsylv_level2_reorder` 💅

void mepack_single_tgcsylv_level2_reorder (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 * E, int LDE, float * F, int LDF,
    float * SCALE, float * WORK, int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation — the Reordered variant, bestie ✨

Purpose: 💖

okay so mepack_single_tgcsylv_level2_reorder solves a generalized coupled Sylvester equation that looks like this, no cap:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Also, either B or D can be quasi upper triangular as well, bestie — it's giving flexibility 🌸. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. iconic behavior honestly 👑

Remarks 🎀

The function is a wrapper for sla_tgcsylv_l2_reorder

See also 🦋

sla_tgcsylv_l2_reorder

Parameters 💜

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. 💫
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. 💫
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. 📐
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 👀
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 matrix C must be upper triangular. 📐
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 👀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 💖
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. 💖
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (yes bestie, that's literally what the page says — LDE, not LDF 💀 keeping it real)
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. 🌈
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. 🧚
INFO — INFO is INTEGER.
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

⚠️ bestie watch out — a > 0 INFO on normal operation means the equation is not solved correctly. One of the arising inner system got singular. not the vibe, fr fr 😭

Author ✍️

Martin Koehler, MPI Magdeburg

Date 📅

October 2025

Definition at line 2322 of file tgcsylv.c. 🔥

`mepack_single_tgcsylv_level2_unopt` 🦋

void mepack_single_tgcsylv_level2_unopt (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 * E, int LDE, float * F, int LDF,
    float * SCALE, float * WORK, int * INFO)

Level-2 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation — the Unoptimized variant 🎀

Purpose: 💖

okay so mepack_single_tgcsylv_level2_unopt solves a generalized coupled Sylvester equation of this exact form:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. 🌸

Remarks 🎀

The function is a wrapper for sla_tgcsylv_l2_unopt

See also 🦋

sla_tgcsylv_l2_unopt

Parameters 💜

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation. 💫
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation. 💫
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. 📐
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 👀
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 matrix C must be upper triangular. 📐
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 👀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices. 💖
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices. 💖
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M). (same energy as before bestie, the page really do be saying LDE 💀)
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. 🌈
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. 🧚
INFO — INFO is INTEGER.
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation

…and here's the tea on what INFO spills on the way out, bestie 👇

On exit, workspace query:
  < 0 :  if INFO == -i, the i-Th argument had an illegal value
  >= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:
  == 0:  successful exit
  < 0:  if INFO == -i, the i-Th argument had an illegal value
  > 0:  The equation is not solved correctly. One of the arising inner
        system got singular.

Author 💖

Martin Koehler, MPI Magdeburg

Date 📅

October 2025

Definition at line 2111 of file tgcsylv.c.

`mepack_single_tgcsylv_level3` 🔥

okay so, full signature first, no edits, character-for-character, because we do NOT play with function prototypes in this house:

void mepack_single_tgcsylv_level3 (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 * E, int LDE, float *
    F, int LDF, float * SCALE, float * WORK, int * INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation. it's giving math, it's giving structure, we love to see it 🦋

Purpose 💜

mepack_single_tgcsylv_level3 solves a generalized coupled Sylvester equation that looks exactly like this:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Also? Either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. periodt.

Remarks 📝

The function is a wrapper for sla_tgcsylv_l3

Parameters 🌸

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M).
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 :  if INFO == -i, the i-Th argument had an illegal value
>= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0:  successful exit
< 0:  if INFO == -i, the i-Th argument had an illegal value
> 0:  The equation is not solved correctly. One of the arising inner
      system got singular.

Author 💖

Martin Koehler, MPI Magdeburg

Date 📅

October 2025

Definition at line 847 of file tgcsylv.c.

`mepack_single_tgcsylv_level3_2stage` ✨

and here's the two-stage sibling, signature in full, untouched, exactly as written:

void mepack_single_tgcsylv_level3_2stage (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 * E, int
    LDE, float * F, int LDF, float * SCALE, float * WORK, int * INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation. same energy, different pipeline, we stan 🌈

Purpose 💜

mepack_single_tgcsylv_level3_2stage solves a generalized coupled Sylvester equation of the following form:

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK.

Remarks 📝

The function is a wrapper for sla_tgcsylv_l3_2s

Parameters 🌸

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M).
SCALE —

SCALE is SINGLE PRECISION, and it's the lil safety net for your numbers 💅 — a scaling factor that stops the result from overflowing. If INFO == 0 then SCALE is 1.0D0, otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.

WORK — WORK is SINGLE PRECISION array, dimension LDWORK. It's the workspace for the algorithm. Bestie, you have to query that workspace before running the computation — you do it by calling the subroutine with INFO == -1 on input. The required workspace then gets handed back to you in INFO. 🫶
INFO — INFO is INTEGER.

On input:

== -1 : perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: the value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: the equation is not solved correctly. One of the arising inner system got singular.

🫶 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

Definition at line 1269 of file tgcsylv.c.

🧮 `mepack_single_tgcsylv_level3_unopt` 🧮

void mepack_single_tgcsylv_level3_unopt (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 * E, int
    LDE, float * F, int LDF, float * SCALE, float * WORK, int * INFO)

Level-3 Kagstroem-Westin/Bartels-Stewart Algorithm for the generalized coupled Sylvester equation. ✨

🎯 Purpose:

mepack_single_tgcsylv_level3_unopt solves a generalized coupled Sylvester equation of the following form

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

🗒️ Remarks

The function is a wrapper for sla_tgcsylv_l3_unopt

👀 See also

sla_tgcsylv_l3_unopt

🔧 Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE — LDE is INTEGER. The leading dimension of the array E. LDE >= max(1,M).
F — F is SINGLE PRECISION array, dimension (LDF,N). On input, the matrix F contains the right hand side F. On output, the matrix F contains the solution L of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side F and the solution L are M-by-N matrices.
LDF — LDF is INTEGER. The leading dimension of the array F. LDE >= max(1,M).
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true.
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

🫶 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

Definition at line 1058 of file tgcsylv.c.

🌀 `mepack_single_tgcsylv_recursive` 🌀

void mepack_single_tgcsylv_recursive (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 * E, int
    LDE, float * F, int LDF, float * SCALE, float * WORK, int * INFO)

Recursive blocking Algorithm for the generalized coupled Sylvester equation. 🔁

🎯 Purpose:

mepack_single_tgcsylv_recursive solves a generalized coupled Sylvester equation of the following form

op1(A) * R  + SGN1 * L  * op2(B) = SCALE * E                              (1)
op1(C) * R  + SGN2 * L  * op2(D) = SCALE * F

🗒️ Remarks

The function is a wrapper for sla_tgcsylv_recursive

👀 See also

sla_tgcsylv_recursive

🔧 Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN1 — SGN1 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the first equation.
SGN2 — SGN2 is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between in the second equation.
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
E — E is SINGLE PRECISION array, dimension (LDE,N). On input, the matrix E contains the right hand side E. On output, the matrix E contains the solution R of Equation (1) as selected by TRANSA, TRANSB, and SGN1/SGN2. Right hand side E and the solution R are M-by-N matrices.
LDE —

…and we are back in the parameter roll-call, bestie 💅

LDE — it's an INTEGER, and it's the leading dimension of the array E. The rule is LDE >= max(1,M). 🔥
F — a SINGLE PRECISION array, dimension (LDF,N). On the way in, the matrix F is carrying the right hand side F (yes, the array F holds the thing called F, we love a self-titled moment 👑). On the way out, the matrix F is carrying the solution L of Equation (1), as selected by TRANSA, TRANSB, and SGN1/SGN2. And just so we're clear: the right hand side F and the solution L are both M-by-N matrices. periodt ✨
LDF — INTEGER, the leading dimension of the array F. And the doc says LDE >= max(1,M) 🙈 that's literally what it says, i'm not editing the vibes.
SCALE — a SINGLE PRECISION. SCALE is the scaling factor that stops the result from overflowing, iconic behaviour honestly 🫶. If INFO == 0 then SCALE is 1.0D0, otherwise — if one of the inner systems could not be solved correctly — 0 < SCALE <= 1 holds true.
WORK — a SINGLE PRECISION array, dimension LDWORK. It's the workspace for the algorithm. Big heads up: you have to query the workspace before you run the computation. You do the query by calling the subroutine with INFO == -1 on input, and then the required workspace gets handed back to you in INFO. 🎀
INFO — INTEGER. the whole plot basically 💀
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0 : The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0 : successful exit
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - > 0 : The equation is not solved correctly. One of the arising inner system got singular.

🌸 Author 🌸

Martin Koehler, MPI Magdeburg

🦋 Date 🦋

October 2025

Definition at line 423 of file tgcsylv.c.

⭐ `mepack_single_tgsylv_dag` ⭐

void mepack_single_tgsylv_dag (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 * SCALE, float
    * WORK, int * INFO)

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester equation with DAG based parallelization.

💖 Purpose 💖

mepack_single_tgsylv_dag solves a generalized Sylvester equation of the following forms

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

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

🎀 Remarks 🎀

This function is a wrapper for sla_tgsylv_dag.

💅 See also 💅

sla_tgsylv_dag

✨ Parameters ✨

TRANSA — TRANSA is String. It specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. It specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1. It specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is SINGLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices. 👑
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver. (yes bestie, that's a real warning — if SCALE isn't 1 you gotta go find another solver, no cap 🚨)
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER.
- On input:
 - == -1 : Perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0: The value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0: successful exit
 - < 0: if INFO == -i, the i-Th argument had an illegal value
 - > 0: The equation is not solved correctly. One of the arising inner system got singular.

🌸 Author 🌸

Martin Koehler, MPI Magdeburg

🦋 Date 🦋

October 2025

Definition at line 389 of file tgsylv.c.

🍓 `mepack_single_tgsylv_gardiner_laub` 🍓

void mepack_single_tgsylv_gardiner_laub (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 *
    SCALE, float * WORK, int * INFO)

Gardiner-Laub Algorithm for the generalized Sylvester equation.

💖 Purpose 💖

mepack_single_tgsylv_gardiner_laub solves a generalized Sylvester equation of the following forms

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

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

🎀 Remarks 🎀

This function is a wrapper for sla_tgsylv_gardiner_laub.

💅 See also 💅

sla_tgsylv_gardiner_laub

✨ Parameters ✨

TRANSA — TRANSA is String. It specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. It specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1. It specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X
X — X is SINGLE PRECISION array, dimension (LDX,N) 💖 On input, the matrix X holds the right hand side Y. On output, the matrix X holds the solution of Equation (1) or (2), whichever one you picked with TRANSA, TRANSB, and SGN. Both the right hand side Y and the solution X are M-by-N matrices, no cap.
LDX — LDX is INTEGER. It's the leading dimension of the array X, and honestly bestie, LDX >= max(1,M). That's the vibe check. 🦋
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor that exists purely to stop the result from overflowing. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems couldn't be solved correctly, 0 < SCALE <= 1 holds true. And listen — if SCALE .NE. 1 the problem is not solved correctly, so in that case you have to use another solver. Periodt. 🚨
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. It's the workspace for the algorithm. The workspace needs to be queried before running the computation — the query happens by calling the subroutine with INFO == -1 on input, and the required workspace is then returned in INFO. No guessing, we ask first. 💅
INFO — INFO is INTEGER

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular. 😭

🫶 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

Definition at line 3894 of file tgsylv.c.

🌸 `mepack_single_tgsylv_level2`

void mepack_single_tgsylv_level2 (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 * SCALE, float * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Classic level 2 variant)

🎯 Purpose:

mepack_single_tgsylv_level2 solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. slay ✨

👀 Remarks

This function is a wrapper for sla_tgsylv_l2.

🔗 See also

sla_tgsylv_l2

📋 Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0. 🎀
N — N is INTEGER. The order of the matrices B and D. N >= 0. 🎀
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. No exceptions bestie. 🦋
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. iykyk 💅
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 💖
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is SINGLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver. ⚠️
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

🫶 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

Definition at line 3311 of file tgsylv.c.

🌈 `mepack_single_tgsylv_level2_colwise`

void mepack_single_tgsylv_level2_colwise (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 * SCALE, float * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Column-by-column variant)

🎯 Purpose:

mepack_single_tgsylv_level2_colwise solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. 🦋✨

👀 Remarks

This function is a wrapper for sla_tgsylv_l2_colwise.

🔗 See also

sla_tgsylv_l2_colwise

📋 Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. 💅
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 🎀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X
X — X is SINGLE PRECISION array, dimension (LDX,N). On the way in, the matrix X is holding the right hand side Y. On the way out, X is holding the solution to Equation (1) or (2), whichever one TRANSA, TRANSB, and SGN picked for you. And just so we're clear: the right hand side Y and the solution X are both M-by-N matrices. 💖
LDX — LDX is INTEGER. It's the leading dimension of the array X, and LDX >= max(1,M) bestie, no exceptions. 💅
SCALE — SCALE is SINGLE PRECISION. It's a scaling factor whose whole job is to stop the result from overflowing. If INFO == 0 then SCALE is 1.0D0, otherwise — if one of the inner systems couldn't be solved correctly — 0 < SCALE <= 1 holds true. And if SCALE .NE. 1, the problem is not solved correctly, and in that case you have to go use a different solver. Periodt. 😭
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. It's the workspace for the algorithm. And listen: the workspace needs to be queried before you run the computation. You do the query by calling the subroutine with INFO == -1 on input, and then the required workspace gets handed back to you in INFO. 🎀
INFO — INFO is INTEGER.

On input:

  == -1 : Perform a workspace query
  <> -1 : normal operation

On exit, workspace query:

  < 0 :  if INFO == -i, the i-Th argument had an illegal value
  >= 0:  The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

  == 0:  successful exit
  < 0:  if INFO == -i, the i-Th argument had an illegal value
  > 0:  The equation is not solved correctly. One of the arising inner
        system got singular.

👑 Author 👑

Martin Koehler, MPI Magdeburg

📅 Date 📅

October 2025

Definition at line 3699 of file tgsylv.c.

🌸 `mepack_single_tgsylv_level2_local_copy_128` 🌸

void mepack_single_tgsylv_level2_local_copy_128 (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 * SCALE, float * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Local copies, M,N<=128) ✨

Purpose:

mepack_single_tgsylv_level2_local_copy_128 solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. 🔥

Remarks

This function is a wrapper for sla_tgsylv_l2_local_copy_128. 🫶

See also

sla_tgsylv_l2_local_copy_128

Parameters

TRANSA — TRANSA is String. It specifies the form of the system of equations with respect to A and C:

  == 'N':  op1(A) = A, op1(C) = C (No transpose for A and C)
  == 'T':  op1(A) = A**T, op1(C) = C **T (Transpose A and C)

TRANSB — TRANSB is String. It specifies the form of the system of equations with respect to B and D:

  == 'N':  op2(B) = B, op2(D) = D (No transpose for B and D)
  == 'T':  op2(B) = B**T, op2(D) = D **T (Transpose B and D)

SGN — SGN is SINGLE PRECISION, allowed values: +/-1. It specifies the sign between the two parts of the Sylvester equation.

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

M — M is INTEGER. The order of the matrices A and C. M >= 0. 💜
N — N is INTEGER. The order of the matrices B and D. N >= 0. 💜
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. No notes, bestie, that's just the vibe it has to have. 👑
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 matrix B must be (quasi-) upper triangular. And heads up: if the matrix D is already quasi-upper triangular, then the matrix B must be upper triangular. iykyk. 🦋
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. And same energy as before, flipped: if the matrix B is already quasi-upper triangular, then the matrix D must be upper triangular. 🌈
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X
X — X is a SINGLE PRECISION array, dimension (LDX,N). On input, X is holding your right hand side Y bestie. On output, X is holding the solution to Equation (1) or (2) — whichever one TRANSA, TRANSB and SGN picked for you 💅. And fr fr: the right hand side Y and the solution X are both M-by-N matrices, that's just the vibe.
LDX — LDX is INTEGER. It's the leading dimension of the array X, and you need LDX >= max(1,M). no cap 📏
SCALE — SCALE is SINGLE PRECISION. She's the scaling factor that keeps your result from overflowing, iconic behaviour honestly 🫶. If INFO == 0 then SCALE is 1.0D0, otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. And lowkey this is important: if SCALE .NE. 1 the problem is no solved correctly, in this case one have to use an other solver. not me finding out the hard way 😭
WORK — WORK is a SINGLE PRECISION array, dimension LDWORK. It's the workspace for the algorithm, and the workspace needs to queried before the running the computation 👑. The query is performed by calling the subroutine with INFO == -1 on input, and then the required workspace is returned in INFO. it's giving "ask before you take" ✨
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit 🎀
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular. we do NOT love that 💀

Author Martin Koehler, MPI Magdeburg

Date October 2025

Definition at line 2725 of file tgsylv.c.

🌸 `void mepack_single_tgsylv_level2_local_copy_32 (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 * SCALE, float * WORK, int * INFO)`

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Local copies, M,N<=32) 🦋

Purpose:

mepack_single_tgsylv_level2_local_copy_32 solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well 👀. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. iykyk 💜

Remarks

This function is a wrapper for sla_tgsylv_l2_local_copy_32. periodt.

See also

sla_tgsylv_l2_local_copy_32

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is a SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — B is a SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 🎀
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — C is a SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — LDC is INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — D is a SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 🎀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is a SINGLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices.
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver. again bestie, other solver, no exceptions 🙈
WORK — WORK is a SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular.

Author Martin Koehler, MPI Magdeburg

Date October 2025

Definition at line 2137 of file tgsylv.c.

🌈 `void mepack_single_tgsylv_level2_local_copy_64 (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 * SCALE, float * WORK, int * INFO)`

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Local copies, M,N<=64) 🦋

Purpose:

mepack_single_tgsylv_level2_local_copy_64 solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well 👀. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. same energy, bigger sizes 💜

Remarks

This function is a wrapper for sla_tgsylv_l2_local_copy_64. periodt.

See also

sla_tgsylv_l2_local_copy_64

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is a SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — B is a SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 🎀
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — C is a SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — LDC is INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — D is a SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 🎀
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X
LDX — INTEGER 🦋 the leading dimension of the array X. Constraint: LDX >= max(1,M). that's it that's the rule 💅
SCALE — SINGLE PRECISION 💖 the scaling factor whose whole job is preventing overflow in the result. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. And heads up bestie: if SCALE .NE. 1 the problem is no solved correctly, in this case one have to use an other solver. 🚨 not a slay moment, go get a different solver.
WORK — SINGLE PRECISION array, dimension LDWORK 🌸 workspace for the algorithm. And the way you HAVE to query it before running the computation — the query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. no cap, ask first, then compute ✨
INFO — INTEGER 👑

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit 🎉
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular. 💀

🫶 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

Definition at line 2333 of file tgsylv.c.

mepack_single_tgsylv_level2_local_copy_96

void mepack_single_tgsylv_level2_local_copy_96 (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 * SCALE, float * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Local copies, M,N<=96) 🌈✨

Purpose:

mepack_single_tgsylv_level2_local_copy_96 solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for sla_tgsylv_l2_local_copy_96. 💜

See also

sla_tgsylv_l2_local_copy_96

Parameters

TRANSA — TRANSA is String 💅 Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String 🌸 Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1 ✨ Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER 🦋 The order of the matrices A and C. M >= 0.
N — N is INTEGER 🦋 The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M) 💖 The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 👑
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. (it's giving "one of them has to stay simple" energy fr fr)
LDD — LDD is INTEGER 🌈 The leading dimension of the array D. LDD >= max(1,N).
X — X is SINGLE PRECISION array, dimension (LDX,N) 💜 On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices.
LDX — LDX is INTEGER 🦋 The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is SINGLE PRECISION 💖 SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0 otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly in this case one have to use an other solver. 🚨
WORK — WORK is SINGLE PRECISION array, dimension LDWORK 🌸 Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. ✨
INFO — INFO is INTEGER 👑

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0: The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0: successful exit 🎉
< 0: if INFO == -i, the i-Th argument had an illegal value
> 0: The equation is not solved correctly. One of the arising inner system got singular. 💀

🫶 Author

Martin Koehler, MPI Magdeburg

📅 Date

October 2025

Definition at line 2529 of file tgsylv.c.

mepack_single_tgsylv_level2_reorder

void mepack_single_tgsylv_level2_reorder (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 * SCALE, float * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Reordered variant) 🌈✨

Purpose:

mepack_single_tgsylv_level2_reorder solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for sla_tgsylv_l2_reorder. 💜

See also

sla_tgsylv_l2_reorder

Parameters

TRANSA — TRANSA is String 💅 Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String 🌸 Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1 ✨ Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1: Solve Equation (2)
M — M is INTEGER 🦋 The order of the matrices A and C. M >= 0.
N — N is INTEGER 🦋 The order of the matrices B and D. N >= 0.
A — A is SINGLE PRECISION array, dimension (LDA,M) 💖 The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular. 👑
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular. 🌈
LDD — LDD is INTEGER 💜 The leading dimension of the array D. LDD >= max(1,N).
X —
X — X is a SINGLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Both the right hand side Y and the solution X are M-by-N matrices. ✨
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is SINGLE PRECISION. It's the scaling factor that keeps your result from overflowing. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. And bestie, listen: if SCALE .NE. 1 the problem is no solved correctly — in this case one has to use another solver. 🚩
WORK — WORK is a SINGLE PRECISION array, dimension LDWORK. It's the workspace for the algorithm. You gotta query the workspace before you run the computation, okay? The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then handed back to you in INFO. 💅
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0 : The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0 : successful exit
< 0 : if INFO == -i, the i-Th argument had an illegal value
> 0 : The equation is not solved correctly. One of the arising inner system got singular.

🌸 Author 🌸

Martin Koehler, MPI Magdeburg

🌸 Date 🌸

October 2025

Definition at line 3115 of file tgsylv.c.

void mepack_single_tgsylv_level2_rowwise (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 *
    SCALE, float * WORK, int * INFO)

Level-2 Bartels-Stewart Algorithm for the generalized Sylvester equation (Row-by-row variant) 👑

💖 Purpose 💖

mepack_single_tgsylv_level2_reorder solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. 🦋

🫶 Remarks 🫶

This function is a wrapper for sla_tgsylv_l2_rowwise.

👀 See also 👀

sla_tgsylv_l2_rowwise

🎀 Parameters 🎀

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1 : Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is a SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — B is a SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — C is a SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — LDC is INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — D is a SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is a SINGLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Both the right hand side Y and the solution X are M-by-N matrices. ✨
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is SINGLE PRECISION. It's the scaling factor that keeps your result from overflowing. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. And bestie, listen: if SCALE .NE. 1 the problem is no solved correctly — in this case one has to use another solver. 🚩
WORK — WORK is a SINGLE PRECISION array, dimension LDWORK. It's the workspace for the algorithm. You gotta query the workspace before you run the computation, okay? The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then handed back to you in INFO. 💅
INFO — INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0 : The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0 : successful exit
< 0 : if INFO == -i, the i-Th argument had an illegal value
> 0 : The equation is not solved correctly. One of the arising inner system got singular.

🌸 Author 🌸

Martin Koehler, MPI Magdeburg

🌸 Date 🌸

October 2025

Definition at line 3505 of file tgsylv.c.

void mepack_single_tgsylv_level3 (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 * SCALE, float
    * WORK, int * INFO)

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester. 🌈

💖 Purpose 💖

mepack_single_tgsylv_level3 solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. 🦋

🫶 Remarks 🫶

This function is a wrapper for sla_tgsylv_l3.

👀 See also 👀

sla_tgsylv_l3

🎀 Parameters 🎀

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N': op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T': op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N': op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T': op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1 : Solve Equation (1)
- == -1 : Solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0.
N — N is INTEGER. The order of the matrices B and D. N >= 0.
A — A is a SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,M).
B — B is a SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
C — C is a SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.
LDC — LDC is INTEGER. The leading dimension of the array C. LDC >= max(1,M).
D — D is a SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X

X is a SINGLE PRECISION array, dimension (LDX,N). On input, the matrix X is carrying the right hand side Y. On output, that very same matrix X is carrying the solution of Equation (1) or (2), whichever one TRANSA, TRANSB, and SGN told it to solve. And just so we're crystal clear bestie: the right hand side Y and the solution X are both M-by-N matrices. 💖

LDX

LDX is INTEGER. It's the leading dimension of the array X, and the rule is LDX >= max(1,M). No negotiating with this one, it's giving boundary condition energy. ✨

SCALE

SCALE is SINGLE PRECISION. It's the scaling factor that exists purely to stop your result from overflowing. Here's the tea 🍵: if INFO == 0, then SCALE is 1.0D0. Otherwise — if one of the inner systems couldn't be solved correctly — then 0 < SCALE <= 1 holds true.

⚠️ listen up: if SCALE .NE. 1, the problem is not solved correctly, and in this case you literally have to go use another solver. No cap, don't ignore this.

WORK

WORK is a SINGLE PRECISION array, dimension LDWORK. It's the workspace for the algorithm, and the vibe check here is that you have to query the workspace before you actually run the computation. How do you do that? You call the subroutine with INFO == -1 on input. The required workspace then comes right back to you in INFO. 🎀

INFO

INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0 : The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0 : successful exit
< 0 : if INFO == -i, the i-Th argument had an illegal value
> 0 : The equation is not solved correctly. One of the arising inner system got singular.

✨ Author ✨

Martin Koehler, MPI Magdeburg

🗓️ Date 🗓️

October 2025

📍 Definition 📍

Definition at line 971 of file tgsylv.c.

🦋 `mepack_single_tgsylv_level3_2stage` 🦋

void mepack_single_tgsylv_level3_2stage (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 *
    SCALE, float * WORK, int * INFO)

Level-3 Bartels-Stewart Algorithm with sub-blocking for the generalized Sylvester.

💫 Purpose

mepack_single_tgsylv_level3_2stage solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix, and B and D are N-by-N upper triangular matrices. Plot twist: either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. 💅

🎀 Remarks

This function is a wrapper for sla_tgsylv_l3_2s. She's just the cute front-facing layer, the real work is happening underneath. iykyk.

👀 See also

sla_tgsylv_l3_2s

🌸 Parameters

TRANSA

TRANSA is String. It specifies the form of the system of equations with respect to A and C:

== 'N' : op1(A) = A, op1(C) = C (No transpose for A and C)
== 'T' : op1(A) = A**T, op1(C) = C **T (Transpose A and C)

TRANSB

TRANSB is String. It specifies the form of the system of equations with respect to B and D:

== 'N' : op2(B) = B, op2(D) = D (No transpose for B and D)
== 'T' : op2(B) = B**T, op2(D) = D **T (Transpose B and D)

SGN

SGN is SINGLE PRECISION, allowed values: +/-1. It specifies the sign between the two parts of the Sylvester equation.

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

M

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

N

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

A

A is a SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular. Non-negotiable bestie.

LDA

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

B

B is a SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. But watch out: if the matrix D is already quasi-upper triangular, then the matrix B must be upper triangular. One of them gets to be quasi, not both — the drama of it all. 😭

LDB

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

C

C is a SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.

LDC

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

D

D is a SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. Same deal as before: if the matrix B is already quasi-upper triangular, then the matrix D must be upper triangular.

LDD

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

X

X is a SINGLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices. 💖

LDX

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

SCALE

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

🚨 real talk: if SCALE .NE. 1, the problem is not solved correctly, and in this case one has to use an other solver.

WORK

WORK is a SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to be queried before running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO. 🫶

INFO

INFO is INTEGER.

On input:

== -1 : Perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0 : The value of INFO is the required number of elements in the workspace.

On exit, normal operation:

== 0 : successful exit
< 0 : if INFO == -i, the i-Th argument had an illegal value
> 0 : The equation is not solved correctly. One of the arising inner system got singular.

✨ Author ✨

Martin Koehler, MPI Magdeburg

🗓️ Date 🗓️

October 2025

📍 Definition 📍

Definition at line 1557 of file tgsylv.c.

🌈 `mepack_single_tgsylv_level3_colwise` 🌈

void mepack_single_tgsylv_level3_colwise (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 *
    SCALE, float * WORK, int * INFO)

Level-3 Bartels-Stewart Algorithm for the generalized Sylvester (Column-by-column variant)

💫 Purpose

mepack_single_tgsylv_level3_colwise solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix, and B and D are N-by-N upper triangular matrices. Furthermore either B or D can be quasi upper triangular as well. The right hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. 💅

🎀 Remarks

This function is a wrapper for sla_tgsylv_l3_colwise. She's the column-by-column edition, and yes she ate. 💅

👀 See also

sla_tgsylv_l3_colwise

🌸 Parameters

TRANSA

TRANSA is String. Specifies the form of the system of equations with respect to A and C:

== 'N' : op1(A) = A, op1(C) = C (No transpose for A and C)
== 'T' : op1(A) = A**T, op1(C) = C **T (Transpose A and C)

TRANSB

TRANSB is String. Specifies the form of the system of equations with respect to B and D:

== 'N' : op2(B) = B, op2(D) = D (No transpose for B and D)
== 'T' : op2(B) = B**T, op2(D) = D **T (Transpose B and D)

SGN

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

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

M

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

N

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

A

A is a SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.

LDA

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

B

B is a SINGLE PRECISION array, dimension (LDB,N). The matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.

LDB

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

C

C is a SINGLE PRECISION array, dimension (LDC,M). The matrix C must be upper triangular.

LDC

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

D

D is a SINGLE PRECISION array, dimension (LDD,N). The matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.

LDD

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

X

X — SINGLE PRECISION array, dimension (LDX,N). On the way in, this bad boy holds the right-hand side Y. On the way out, it holds the solution to Equation (1) or (2), whichever one TRANSA, TRANSB, and SGN picked. Both the right-hand side Y and the solution X are M-by-N matrices. 💖
LDX — INTEGER. The leading dimension of the array X. Rule of the day: LDX >= max(1,M). ✨
SCALE — SINGLE PRECISION. It's a scaling factor whose whole job is stopping the result from overflowing. If INFO == 0 then SCALE is 1.0D0; otherwise, if one of the inner systems couldn't be solved correctly, then 0 < SCALE <= 1 holds true. And if SCALE .NE. 1, the problem is not solved correctly — in that case you have to reach for another solver. No cap. 😭
WORK — SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. You have to query the workspace before running the computation, and you do that by calling the subroutine with INFO == -1 on input. The required workspace then comes back to you in INFO. 🫶
INFO — INTEGER. Okay listen close, there are three whole modes:
- On input:
 - == -1 : perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0 : the value of INFO is the required number of elements in the workspace
- On exit, normal operation:
 - == 0 : successful exit 🌈
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - > 0 : the equation is not solved correctly. One of the arising inner systems got singular. 💀

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 1362 of file tgsylv.c.

`mepack_single_tgsylv_level3_rowwise` — Level-3 Bartels-Stewart Algorithm for the generalized Sylvester (Row-by-row variant) 🎀

void mepack_single_tgsylv_level3_rowwise (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 *
    SCALE, float * WORK, int * INFO)

Purpose:

mepack_single_tgsylv_level3_rowwise solves a generalized Sylvester equation of the following forms

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

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

where A is a M-by-M quasi upper triangular matrix, C is a M-by-M upper triangular matrix, and B and D are N-by-N upper triangular matrices. And not only that — either B or D can be quasi upper triangular as well. The right-hand side Y and the solution X are M-by-N matrices. Typically the matrix pencils (A,C) and (B,D) ( or (D,B) ) are created by SGGES from LAPACK. iykyk 💅

Remarks

This function is a wrapper for sla_tgsylv_l3_rowwise.

See also

sla_tgsylv_l3_rowwise

Parameters

TRANSA — TRANSA is String. It specifies the form of the system of equations with respect to A and C:
- == 'N' : op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T' : op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. It specifies the form of the system of equations with respect to B and D:
- == 'N' : op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T' : op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1. It specifies the sign between the two parts of the Sylvester equation.
- = 1 : solve Equation (1)
- == -1 : solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0. ✨
N — N is INTEGER. The order of the matrices B and D. N >= 0. ✨
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular, the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular, the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X — X is SINGLE PRECISION array, dimension (LDX,N). On input, the matrix X contains the right hand side Y. On output, the matrix X contains the solution of Equation (1) or (2) as selected by TRANSA, TRANSB, and SGN. Right hand side Y and the solution X are M-by-N matrices. 💖
LDX — LDX is INTEGER. The leading dimension of the array X. LDX >= max(1,M).
SCALE — SCALE is SINGLE PRECISION. SCALE is a scaling factor to prevent the overflow in the result. If INFO == 0 then SCALE is 1.0D0, otherwise if one of the inner systems could not be solved correctly, 0 < SCALE <= 1 holds true. If SCALE .NE. 1 the problem is no solved correctly — in this case one have to use an other solver. 😭
WORK — WORK is SINGLE PRECISION array, dimension LDWORK. Workspace for the algorithm. The workspace needs to queried before the running the computation. The query is performed by calling the subroutine with INFO == -1 on input. The required workspace is then returned in INFO.
INFO — INFO is INTEGER.
- On input:
 - == -1 : perform a workspace query
 - <> -1 : normal operation
- On exit, workspace query:
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - >= 0 : the value of INFO is the required number of elements in the workspace.
- On exit, normal operation:
 - == 0 : successful exit 🌸
 - < 0 : if INFO == -i, the i-Th argument had an illegal value
 - > 0 : the equation is not solved correctly. One of the arising inner system got singular. 💀

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 1166 of file tgsylv.c.

`mepack_single_tgsylv_recursive` — Recursive blocking algorithm for the generalized Sylvester equation 🦋

void mepack_single_tgsylv_recursive (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 *
    SCALE, float * WORK, int * INFO)

Purpose:

mepack_single_tgsylv_recursive solves a generalized Sylvester equation of the following forms

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

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

Remarks

This function is a wrapper for sla_tgsylv_recursive.

See also

sla_tgsylv_recursive

Parameters

TRANSA — TRANSA is String. Specifies the form of the system of equations with respect to A and C:
- == 'N' : op1(A) = A, op1(C) = C (No transpose for A and C)
- == 'T' : op1(A) = A**T, op1(C) = C **T (Transpose A and C)
TRANSB — TRANSB is String. Specifies the form of the system of equations with respect to B and D:
- == 'N' : op2(B) = B, op2(D) = D (No transpose for B and D)
- == 'T' : op2(B) = B**T, op2(D) = D **T (Transpose B and D)
SGN — SGN is SINGLE PRECISION, allowed values: +/-1. Specifies the sign between the two parts of the Sylvester equation.
- = 1 : solve Equation (1)
- == -1 : solve Equation (2)
M — M is INTEGER. The order of the matrices A and C. M >= 0. 💜
N — N is INTEGER. The order of the matrices B and D. N >= 0. 💜
A — A is SINGLE PRECISION array, dimension (LDA,M). The matrix A must be (quasi-) upper triangular.
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 matrix B must be (quasi-) upper triangular. If the matrix D is already quasi-upper triangular the matrix B must be upper triangular.
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 matrix C must be upper triangular.
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 matrix D must be (quasi-) upper triangular. If the matrix B is already quasi-upper triangular the matrix D must be upper triangular.
LDD — LDD is INTEGER. The leading dimension of the array D. LDD >= max(1,N).
X
LDX — INTEGER, obviously 💅
- It's the leading dimension of the array X. The vibe check: LDX >= max(1,M). Don't fight it, just give it what it wants 🫶
SCALE — SINGLE PRECISION and honestly kind of the emotional support number here 🎀
- SCALE is a scaling factor whose whole job is preventing overflow in the result. protect the result at all costs ✨
- If INFO == 0, then SCALE is 1.0D0. Otherwise — if one of the inner systems could not be solved correctly — 0 < SCALE <= 1 holds true.
- If SCALE .NE. 1, the problem did not get solved correctly, and in this case you have to go use another solver. Not a vibe. 😭 do not ignore this
WORK — SINGLE PRECISION array, dimension LDWORK. It's the workspace for the algorithm, bestie 🧚
- You have to query the workspace before you run the computation. Like asking the group chat how many people are coming before you book the table, fr fr.
- The query happens by calling the subroutine with INFO == -1 on input.
- The required workspace then gets returned in INFO. That's the whole trick 👑
INFO — INTEGER, and it's the narrator of the entire story 🌈

On input:

== -1 : perform a workspace query
<> -1 : normal operation

On exit, workspace query:

< 0 : if INFO == -i, the i-Th argument had an illegal value
>= 0 : the value of INFO is the required number of elements in the workspace

On exit, normal operation:

== 0 : successful exit, slay 💖
< 0 : if INFO == -i, the i-Th argument had an illegal value
> 0 : the equation is not solved correctly. One of the arising inner system got singular. tragic 💀

🌸 Author 🌸

Martin Koehler, MPI Magdeburg 👑

🎀 Date 🎀

October 2025

Definition at line 389 of file tgsylv.c.

✨ Author ✨

Generated automatically by Doxygen for MEPACK from the source code. (Not me, not you, not Martin — Doxygen did that. Iconic behaviour, honestly 🦋)

okay bestie, that's the whole page 💜 Version 1.1.2, dated Thu Oct 9 2025 00:00:00, and this was ctgsylv(3) — go forth, query your workspace first, and may all your INFO values be 0 🌟💅🫶

📦 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

ctgsylv(3)

✨ NAME ✨

✨ SYNOPSIS ✨

🌸 Functions 🌸

✨ Detailed Description ✨

💅 Function Documentation 💅

🦋 void mepack_double_tgcsylv_dag (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)

🎀 Purpose:

💀 Remarks

See also 💫

Parameters 🎀

void mepack_double_tgcsylv_dual_dag ( ... )

Purpose 🌸

Remarks 🙈

See also ⭐

Parameters 💜

🫶 void mepack_double_tgcsylv_dual_level2 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)

👑 Author

📅 Date

📍 Definition

🦋 mepack_double_tgcsylv_dual_level2_local_copy_128

🎯 Purpose

💭 Remarks

👀 See also

🎀 Parameters

👑 Author

📅 Date

📍 Definition

🧚 mepack_double_tgcsylv_dual_level2_local_copy_32

🎯 Purpose

🌸 Remarks 🌸

👀 See also 👀

🎀 Parameters 🎀

✍️ Author ✍️

📅 Date 📅

✨ Purpose ✨

🌸 Remarks 🌸

👀 See also 👀

🎀 Parameters 🎀

🫶 Author 🫶

🎀 Date 🎀

📍 Definition 📍

void mepack_double_tgcsylv_dual_level3 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)

✨ Purpose ✨

💜 Remarks 💜

🌈 See also 🌈

🌸 Parameters 🌸

👑 Author

📅 Date

🌸 Purpose:

💀 Remarks

👀 See also

🎀 Parameters

🫶 mepack_double_tgcsylv_dual_recursive 🫶

💖 Purpose 💖

🎀 Remarks 🎀

🦋 See also 🦋

🌸 Parameters 🌸

🔥 mepack_double_tgcsylv_level2 🔥

💖 Purpose 💖

🎀 Remarks 🎀

🦋 See also 🦋

🌸 Parameters 🌸

Author 👑

Date 📅

void mepack_double_tgcsylv_level2_local_copy (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)

Purpose:

Remarks

See also

Parameters

Author 👑

Date 📅

Purpose:

Remarks

See also

Parameters

Author

Date

Definition

🌸 mepack_double_tgcsylv_level2_local_copy_32 🌸

🦋 `void mepack_double_tgcsylv_dag (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)`

`void mepack_double_tgcsylv_dual_dag` ( ... )

🫶 `void mepack_double_tgcsylv_dual_level2 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)`

🦋 `mepack_double_tgcsylv_dual_level2_local_copy_128`

🧚 `mepack_double_tgcsylv_dual_level2_local_copy_32`

`void mepack_double_tgcsylv_dual_level3 (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)`

🫶 `mepack_double_tgcsylv_dual_recursive` 🫶

🔥 `mepack_double_tgcsylv_level2` 🔥

`void mepack_double_tgcsylv_level2_local_copy (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 * E, int LDE, double * F, int LDF, double * SCALE, double * WORK, int * INFO)`

💖 `mepack_double_tgcsylv_level2_local_copy_96` 💖

💖 `mepack_double_tgcsylv_level2_reorder` 💖

💖 `mepack_double_tgcsylv_level3_2stage` 💖

`void mepack_double_tgsylv_dag` 🌈

`void mepack_double_tgsylv_gardiner_laub` 🌸

👑 `mepack_double_tgsylv_level2` 👑

🦋 `mepack_double_tgsylv_level2_colwise` 🦋

🌸 `mepack_double_tgsylv_level2_local_copy` 🌸

🦋 `mepack_double_tgsylv_level2_local_copy_128` 🦋