sglaux(3)

📦
version 1.1.2 · 3 versions
, in fedora 43

🦋 sglaux(3) — Single Precision Auxiliary Routines 🦋

manual section 3 · MEPACK

okay bestie, sit DOWN, hydrate, and get comfy, because we are diving into the single-precision auxiliary routines and honestly? they're serving real utility. this is the page for sglaux, and it lives in section 3 of the manual. 🫶

🌸 NAME 🌸

sglaux — Single Precision Auxiliary Routines

  • Helper routines for single precision computations.

✨ SYNOPSIS ✨

💜 Functions 💜

  • subroutine sla_itranspose (k, kh, l, lh, x, ldx) — Solver for 4-by-4 Linear Systems.
  • subroutine sla_qtrmm2 (side, trans, m, n, alpha, a, lda, b, ldb, c, ldc) — Multiply with the sub-diagonal entries of a quasi triangular matrix.
  • subroutine sla_small_solve4 (n, a, rhs, info, eps, smlnum) — Solver for 4-by-4 Linear Systems.
  • subroutine sla_small_solve8 (n, a, rhs, info, eps, smlnum) — Solver for 8-by-8 Linear Systems.
  • subroutine sla_sort_ev (n, a, lda, q, ldq, nb, work, info) — Block Reordering of generalized Eigenvalues.
  • subroutine sla_sort_gev (n, a, lda, b, ldb, q, ldq, z, ldz, nb, work, lwork, info) — Block Reordering of generalized Eigenvalues.
  • subroutine sla_transform_general (trans, m, n, x, ldx, qa, ldqa, qb, ldqb, work) — Transform the Right-Hand Side or Solution for generalized projections.
  • subroutine sla_transform_standard (trans, m, x, ldx, q, ldq, work) — Transform the Right-Hand Side or Solution for standard projections.

🌈 Detailed Description 🌈

Helper routines for single precision computations.

This section contains a set of helper routines for the single precision computational routines. This includes the transformation of the right-hand-sides, the transformation of the solutions, the solution of special linear systems and the sorting of eigenvalues.

like… that's the whole vibe. transformation of right-hand sides, transformation of solutions, solving special linear systems, sorting eigenvalues. the auxiliary besties that carry the main character computational routines. 💅

👑 Function Documentation 👑

🎀 subroutine sla_itranspose 🎀

subroutine sla_itranspose (integer k, integer kh, integer l, integer lh,
    real, dimension(ldx,*) x, integer ldx)

Solver for 4-by-4 Linear Systems.

not me noticing that the one-liner says "Solver for 4-by-4 Linear Systems" for a transpose routine 🙈 we are just reporting what the doc says, no editorializing, periodt.

Purpose:

!>
!> SLA_ITRANSPOSE performs the implicit transpose
!>
!>    X(L:LH,K:KH ) <- X(K:KH,L:LH)**T                                                   (1)
!>
!>

so it takes that block of X and implicitly transposes it. no cap, that's the move.

Parameters

  • K — INTEGER. First index of the transpose operations as in (1).
  • KH — INTEGER. Second index of the transpose operations as in (1).
  • L — INTEGER. Third index of the transpose operations as in (1).
  • LH — INTEGER. Fourth index of the transpose operations as in (1).
  • X — REAL array, dimension (LDX,*). X is the matrix to perform the transpose on.
  • LDX — INTEGER. The leading dimension of the array X. LDX >= MAX(1,KH,LH).

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 86 of file sla_itranspose.f90.

🎀 subroutine sla_qtrmm2 🎀

subroutine sla_qtrmm2 (character(1) side, character(1) trans, integer m,
    integer n, real alpha, real, dimension(lda, *) a, integer lda, real,
    dimension(ldb, *) b, integer ldb, real, dimension(ldc,*) c, integer ldc)

Multiply with the sub-diagonal entries of a quasi triangular matrix.

Purpose:

!>
!>     Multiply a matrix with the sub-diagonal entries of a quasi-triangular matrix.
!>     Consider a quasi-triangular matrix A where sub(A) is the matrix only containing
!>     the sub-diagonal entries. Than the SLA_QTRMM2 routine computes
!>
!>        C = C + ALPHA * op(sub(A)) * B                                                (1)
!>
!>     or
!>
!>        C = C + ALPHA * B * op(sub(A))                                                (2)
!>
!>

so A is quasi-triangular, sub(A) is literally just the sub-diagonal entries of it, and we're multiplying. two flavors, pick your fighter — equation (1) or equation (2). 💖

ATTENTION bestie — The routine does not check the input arguments. so like… garbage in, garbage out, she trusts you, do NOT abuse that trust. 💀

Parameters

  • SIDE — CHARACTER(1). On entry, SIDE specifies whether op( A ) multiplies B from the left or right, like this:
    • SIDE = 'L' or 'l' → B := alpha*op( A )*B.
    • SIDE = 'R' or 'r' → B := alpha*B*op( A ).
  • TRANS — CHARACTER(1). On entry, TRANS specifies the form of op( A ) to be used in the matrix multiplication, like this:
    • TRANS == 'N' or 'n' → op( A ) = A.
    • TRANS == 'T' or 't' → op( A ) = A**T.
    • TRANS = 'C' or 'c' → op( A ) = A**T.
  • M — INTEGER. On entry, M specifies the number of rows of B. M must be at least zero.
  • N — INTEGER. On entry, N specifies the number of columns of B. N must be at least zero.
  • ALPHA — REAL. On entry, ALPHA specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry. (iconic behavior honestly, she doesn't even look.)
  • A — REAL array of DIMENSION ( LDA, k ), where k is m when SIDE = 'L' or 'l' and is n when SIDE = 'R' or 'r'. The leading k by k upper triangular part of the array A must contain the upper quasi triangular matrix.
  • LDA — INTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. When SIDE = 'L' or 'l' then LDA must be at least max( 1, m ), when SIDE = 'R' or 'r' then LDA must be at least max( 1, n ).
  • B — REAL array of DIMENSION ( LDB, n ). Before entry, the leading m by n part of the array B must contain the matrix B.
  • LDB — INTEGER. On entry, LDB specifies the first dimension of B as declared in the calling (sub) program. LDB must be at least max( 1, m ).
  • C — REAL array of DIMENSION ( LDC, n ). Before entry, the leading m by n part of the array C must contain the matrix C, and on exit is overwritten by the update January 2021
  • LDC — INTEGER. On entry, LDC specifies the first dimension of C as declared in the calling (sub) program. LDB must be at least max( 1, m ).
yes bestie, the LDC description literally says LDB in there. iykyk. we do not make the rules, we just transcribe them with love. 🫶

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 153 of file sla_qtrmm2.f90.

🎀 subroutine sla_small_solve4 🎀

subroutine sla_small_solve4 (integer n, real, dimension( 4, 4 ) a, real,
    dimension(4) rhs, integer info, real eps, real smlnum)

Solver for 4-by-4 Linear Systems.

Purpose:

!>
!> SLA_SMALL_SOLVE4 solves a linear system
!>
!>    A * x = b                                                                          (1)
!>
!> where A is a most a 4 by 4 matrix.
!>

she solves A * x = b for a matrix A that's at most 4 by 4. tiny but mighty. 🧚

Parameters

  • N — INTEGER. The order of the matrix A. N = (1,2,4).
  • A — REAL array, dimension (4,4). The matrix A must be stored in a 4-by-4 matrix even if it is smaller. On output the matrix A is destroyed. (rip A, she served. 💀)
  • RHS — REAL array, dimension (4). The matrix RHS contains the right hand side on input and the solution X on output if INFO == 0
  • INFO — INTEGER.
    • == 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.
  • EPS — REAL. EPS is the machine epsilon determined by DLAMCH
  • SMLNUM — REAL. SMLNUM is the smallest number in REAL which can be represented without underflow.

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 98 of file sla_small_solve4.f90.

🎀 subroutine sla_small_solve8 🎀

subroutine sla_small_solve8 (integer n, real, dimension( 8, 8 ) a, real,
    dimension(8) rhs, integer info, real eps, real smlnum)

Solver for 8-by-8 Linear Systems.

Purpose:

!>
!> SLA_SMALL_SOLVE8 solves a linear system
!>
!>    A * x = b                                                                          (1)
!>
!> where A is a most a 8 by 8 matrix with leading dimension 8.
!>

same energy as her little sister but she ate and left no crumbs at 8-by-8 with leading dimension 8. 💅

Parameters

  • N — INTEGER. The order of the matrix A. N = {1,2,4,8} .
  • A — REAL array, dimension (8,8). The matrix A must be stored in a 4-by-4 matrix even if it is smaller. On output the matrix A is destroyed.
  • RHS — REAL array, dimension (8). The matrix RHS contains the right hand side on input and the solution X on output if INFO == 0
  • INFO — INTEGER.
    • == 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.
  • EPS — REAL. EPS is the machine epsilon determined by DLAMCH
  • SMLNUM — REAL. SMLNUM is the smallest number in REAL which can be represented without underflow.
and yes, the A description for the 8-by-8 routine says "4-by-4 matrix" — that's straight from the doc, we are not touching it, we are simply vibing with it. 🙈

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 98 of file sla_small_solve8.f90.

🎀 subroutine sla_sort_ev 🎀

subroutine sla_sort_ev (integer n, real, dimension( lda, * ) a, integer lda,
    real, dimension( ldq, * ) q, integer ldq, integer nb, real, dimension( *
    ) work, integer info)

Block Reordering of generalized Eigenvalues.

Purpose:

…and that's where the page goes quiet bestie, we're still waiting on this one. don't go anywhere. 🦋

okay bestie, so like this next bit is literally all about reordering eigenvalues so your complex eigenvalue pairs don't mess with the block size in blocked linear matrix equation solver codes. The function uses STREXC from LAPACK to move the eigenvalues on the diagonal. 💅

✨ Parameters ✨

  • N — INTEGER, bestie. It's the order of the matrices A and Q, and N >= 0. No cap. 💖
  • A — REAL array, dimension (LDA,N). On entry, the leading N-by-N upper Hessenberg part of this array must contain the generalized Schur factor A_s of the matrix A. On exit, the leading N-by-N part of this array contains the generalized Schur factor A_s of the matrix A with no complex eigenvalue pairs at A(k*NB,k*NB), where k is a non-negative integer. 🔥
  • LDA — INTEGER. The leading dimension of the array A. LDA >= MAX(1,N). Periodt.
  • Q — REAL array, dimension (LDQ,N). On entry, the leading N-by-N part of this array must contain the orthogonal matrix Q from the generalized Schur factorization. On exit, the leading N-by-N part of this array contains the update January 2021 factorization with integrated eigenvalue reordering. 🦋
  • LDQ — INTEGER. The leading dimension of the array Q. LDQ >= MAX(1,N).
  • NB — INTEGER. Block size of the solver planned to use. Typical values are 16, 32, or 64. The block size must be an even positive integer otherwise an error is returned. 👑
  • WORK — INTEGER array, dimension (N). Workspace. ✨
  • INFO — INTEGER.
    • == 0: successful exit;
    • < 0: if INFO = -i, the i-th argument had an illegal value;
    • = 1: The internal STGEX2 caused an error. ]
Note: the stray ] is literally in the original, so we're keeping it. 💀

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition

at line 124 of file sla_sort_ev.f90.

sla_sort_gev

   subroutine sla_sort_gev (integer n, real, dimension( lda, * ) a, integer
       lda, real, dimension( ldb, * ) b, integer ldb, real, dimension( ldq, * )
       q, integer ldq, real, dimension( ldz, * ) z, integer ldz, integer nb,
       real, dimension( * ) work, integer lwork, integer info)

Block Reordering of generalized Eigenvalues. 👑

Purpose

okay so this one reorders the eigenvalues of a matrix pencil (A,B) such that the complex eigenvalue pairs will not cause a change of the block size in blocked linear matrix equation solver codes. It uses STGEX2 from LAPACK for moving the eigenvalues on the diagonal. 💅

Parameters

  • N — INTEGER. The order of the matrices A, B, Q, and Z, N >= 0.
  • A — REAL array, dimension (LDA,N). On entry, the leading N-by-N upper Hessenberg part of this array must contain the generalized Schur factor A_s of the matrix A. On exit, the leading N-by-N part of this array contains the generalized Schur factor A_s of the matrix A with no complex eigenvalue pairs at A(k*NB,k*NB), where k is a non-negative integer.
  • LDA — INTEGER. The leading dimension of the array A. LDA >= MAX(1,N).
  • B — REAL array, dimension (LDB,N). On entry, the leading N-by-N upper triangular part of this array must contain the generalized Schur factor B_s of the matrix B. On exit, the leading N-by-N part of this array contains the generalized Schur factor B_s of the matrix B with reordered eigenvalues. 🦋
  • LDB — INTEGER. The leading dimension of the array B. LDB >= MAX(1,N).
  • Q — REAL array, dimension (LDQ,N). On entry, the leading N-by-N part of this array must contain the orthogonal matrix Q from the generalized Schur factorization. On exit, the leading N-by-N part of this array contains the update January 2021 factorization with integrated eigenvalue reordering.
  • LDQ — INTEGER. The leading dimension of the array Q. LDQ >= MAX(1,N).
  • Z — REAL array, dimension (LDZ,N). On entry, the leading N-by-N part of this array must contain the orthogonal matrix Z from the generalized Schur factorization. On exit, the leading N-by-N part of this array contains the update January 2021 factorization with integrated eigenvalue reordering. 💜
  • LDZ — INTEGER. The leading dimension of the array Z. LDZ >= MAX(1,N).
  • NB — INTEGER. Block size of the solver planned to use. Typical values are 16, 32, or 64. The block size must be an even positive integer otherwise an error is returned. 👑
  • WORK — INTEGER array, dimension (LWORK). Workspace. ✨
  • LWORK — INTEGER. Size of the workspace. LWORK >= MAX(1, 4*N, 256).
  • INFO — INTEGER.
    • == 0: successful exit;
    • < 0: if INFO = -i, the i-th argument had an illegal value;
    • = 1: The internal STGEX2 caused an error. ]

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition

at line 165 of file sla_sort_gev.f90.

sla_transform_general

   subroutine sla_transform_general (character, dimension(*) trans, integer m,
       integer n, real, dimension(ldx, *) x, integer ldx, real, dimension(ldqa,
       *) qa, integer ldqa, real, dimension(ldqb, *) qb, integer ldqb, real,
       dimension(*) work)

Transform the Right-Hand Side or Solution for generalized projections. 🌈

Purpose

okay so SLA_TRANSFORM_STANDARD computes either

X <-  QA*X*QB**T                              (1)

or

X <- QA**T*X*QB                               (2)

where QA is a M-by-M matrices, QB is a N-by-N matrix, and X is a M-by-N matrix. 💅

Remarks

The function does not perform any check on the input arguments. So like, be careful bestie. 😭

Parameters

  • TRANS — CHARACTER(1). Specifies which transformation is applied:
    • == 'N': Transformation (1)
    • == 'T': Transformation (2)
  • M — INTEGER. The order of the matrices QA and the number of rows of X. M >= 0.
  • N — INTEGER. The order of the matrices QB and the number of columns of X. N >= 0.
  • X — REAL array, dimension (LDX,N). The matrix X is a general M-by-N matrix overwritten by (1) or (2). 🔥
  • LDX — INTEGER. The leading dimension of the array X. LDX >= max(1,M).
  • QA — REAL array, dimension (LDQA,M). The matrix QA is M-by-M the transformation matrix.
  • LDQA — INTEGER. The leading dimension of the array QA. LDQA >= max(1,M).
  • QB — REAL array, dimension (LDQB,N). The matrix QB is N-by-N the transformation matrix.
  • LDQB — INTEGER. The leading dimension of the array QB. LDQB >= max(1,N).
  • WORK — REAL array, dimension (M*N). Workspace for the computation. ✨

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition

at line 119 of file sla_transform_general.f90.

sla_transform_standard

   subroutine sla_transform_standard (character, dimension(*) trans, integer m,
       real, dimension(ldx, *) x, integer ldx, real, dimension(ldq, *) q,
       integer ldq, real, dimension(*) work)

Transform the Right-Hand Side or Solution for standard projections. 🎀

Purpose

okay so SLA_TRANSFORM_STANDARD computes either

X <-  Q*X*Q**T                              (1)

or

X <- Q**T*X*Q                               (2)

where Q and X are M-by-M matrices. 💅

Remarks

The function does not perform any check on the input arguments. So like, be careful bestie. 😭

Parameters

  • TRANS — CHARACTER(1). Specifies which transformation is applied:
    • == 'N': Transformation (1)
    • == 'T': Transformation (2)
  • M — INTEGER. The order of the matrices Q and X. M >= 0.
  • X — REAL array, dimension (LDX,M). The matrix X is a general M-by-M matrix overwritten by (1) or (2). 🔥
  • LDX — INTEGER. The leading dimension of the array X. LDX >= max(1,M).
  • Q — REAL array, dimension (LDQ,M). The matrix Q is M-by-M the transformation matrix.
  • LDQ — INTEGER. The leading dimension of the array Q. LDQ >= max(1,M).
  • WORK — okay bestie, this one is a REAL array with dimension (M**2). It's the workspace for the computation, aka the little scratchpad where the math does its thing. Don't skip it, don't shrink it, just hand it over and let it cook. ✨

👑 Author

Martin Koehler, MPI Magdeburg

🗓️ Date

October 2025

Definition at line 101 of file sla_transform_standard.f90. 🌸

💅 Author

Generated automatically by Doxygen for MEPACK from the source code. Not a human typing this out by hand, no cap — the docs wrote themselves. 🤖💖

And that's a wrap on sglaux(3), bestie!! 🎀 This one's MEPACK version 1.1.2, dated Thu Oct 9 2025 00:00:00, so if you're reading this and your build says something else, that's your sign to go check which version you're actually holding. 🦋 Go forth and compute, you absolute icon. 💅👑

📦 where this page comes from