dblaux(3)

📦

version 1.1.2 · 3 versions

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

🌸 dblaux(3) — MEPACK 💖

okay bestie, welcome to dblaux, the double precision auxiliary routines page from MEPACK (section 3, library territory). it's giving backstage-crew energy: these are the helper routines that do the quiet, unglamorous work behind the double precision computational routines so the main characters can shine. 🫶

✨ NAME ✨

dblaux — Double Precision Auxiliary Routines

Helper routines for double precision computations. 💅

✨ SYNOPSIS ✨

🎀 Functions

subroutine dla_itranspose (k, kh, l, lh, x, ldx)
    Solver for 4-by-4 Linear Systems.
subroutine dla_qtrmm2 (side, trans, m, n, alpha, a, lda, b, ldb, c, ldc)
    Multiply with the sub-diagonal entries of a quasi triangular matrix.
subroutine dla_small_solve4 (n, a, rhs, info, eps, smlnum)
    Solver for 4-by-4 Linear Systems.
subroutine dla_small_solve8 (n, a, rhs, info, eps, smlnum)
    Solver for 8-by-8 Linear Systems.
subroutine dla_sort_ev (n, a, lda, q, ldq, nb, work, info)
    Block Reordering of generalized Eigenvalues.
subroutine dla_sort_gev (n, a, lda, b, ldb, q, ldq, z, ldz, nb, work,
    lwork, info)
    Block Reordering of generalized Eigenvalues.
subroutine dla_transform_general (trans, m, n, x, ldx, qa, ldqa, qb,
    ldqb, work)
    Transform the Right-Hand Side or Solution for generalized
    projections.
subroutine dla_transform_standard (trans, m, x, ldx, q, ldq, work)
    Transform the Right-Hand Side or Solution for standard projections.

✨ Detailed Description ✨

Helper routines for double precision computations. 💖

This section contains a set of helper routines for the double 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. no cap, that's the whole vibe. ✨

✨ Function Documentation ✨

🌈 `subroutine dla_itranspose` 🌈

subroutine dla_itranspose (integer k, integer kh, integer l, integer lh,
    double precision, dimension(ldx,*) x, integer ldx)

Solver for 4-by-4 Linear Systems. (that's what the one-liner says, bestie — we're just reporting it faithfully 🫡)

Purpose:

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

Parameters

K

!>          K is INTEGER
!>          First index of the transpose operations as in (1)
!>

KH

!>          KH is INTEGER
!>          Second index of the transpose operations as in (1)
!>

L

!>          L is INTEGER
!>          Third index of the transpose operations as in (1)
!>

LH

!>          LH is INTEGER
!>          Fourth index of the transpose operations as in (1)
!>

X

!>          X is DOUBLE PRECISION array, dimension (LDX,*)
!>          X is the matrix to perform the transpose on.
!>

LDX

!>             LDX  is  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 dla_itranspose.f90.

🌈 `subroutine dla_qtrmm2` 🌈

subroutine dla_qtrmm2 (character(1) side, character(1) trans, integer m,
    integer n, double precision alpha, double precision, dimension(lda, *)
    a, integer lda, double precision, dimension(ldb, *) b, integer ldb,
    double precision, 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 DLA_QTRMM2 routine computes
!>
!>        C = C + ALPHA * op(sub(A)) * B                                                (1)
!>
!>     or
!>
!>        C = C + ALPHA * B * op(sub(A))                                                (2)
!>
!>

⚠️ Attention — The routine does not check the input arguments. bestie. it trusts you completely. do not betray it. 😭

Parameters

SIDE

!>          SIDE is CHARACTER(1)
!>           On entry,  SIDE specifies whether  op( A ) multiplies B from
!>           the left or right as follows:
!>
!>              SIDE = 'L' or 'l'   B := alpha*op( A )*B.
!>
!>              SIDE = 'R' or 'r'   B := alpha*B*op( A ).
!>

TRANS

!>          TRANS is CHARACTER(1)
!>           On entry, TRANS specifies the form of op( A ) to be used in
!>           the matrix multiplication as follows:
!>
!>              TRANS == 'N' or 'n'   op( A ) = A.
!>
!>              TRANS == 'T' or 't'   op( A ) = A**T.
!>
!>              TRANS = 'C' or 'c'   op( A ) = A**T.
!>

M

!>          M is INTEGER
!>           On entry, M specifies the number of rows of B. M must be at
!>           least zero.
!>

N

!>          N is INTEGER
!>           On entry, N specifies the number of columns of B.  N must be
!>           at least zero.
!>

ALPHA

!>          ALPHA is DOUBLE PRECISION.
!>           On entry,  ALPHA specifies the scalar  alpha. When  alpha is
!>           zero then  A is not referenced and  B need not be set before
!>           entry.
!>

A

!>           A is DOUBLE PRECISION 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

!>          LDA is 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

!>           B is DOUBLE PRECISION array of DIMENSION ( LDB, n ).
!>           Before entry,  the leading  m by n part of the array  B must
!>           contain the matrix  B.
!>

LDB

!>          LDB is 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

!>           C is DOUBLE PRECISION 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

!>          LDC is 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 ).
!>

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 153 of file dla_qtrmm2.f90.

🌈 `subroutine dla_small_solve4` 🌈

subroutine dla_small_solve4 (integer n, double precision, dimension( 4, 4 )
    a, double precision, dimension(4) rhs, integer info, double precision
    eps, double precision smlnum)

Solver for 4-by-4 Linear Systems.

Purpose:

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

Parameters

N

!>          N is INTEGER
!>          The order of the matrix A  N = (1,2,4).
!>

A

!>          A is DOUBLE PRECISION 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.
!>

RHS

!>          RHS is DOUBLE PRECISION array, dimension (4)
!>          The matrix RHS contains the right hand side on input and the solution X on output if INFO == 0
!>

INFO

!>          INFO is 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

!>          EPS is DOUBLE PRECISION
!>          EPS is the machine epsilon determined by DLAMCH
!>

SMLNUM

!>          SMLNUM is DOUBLE PRECISION
!>          SMLNUM is the smallest number in DOUBLE PRECISION which can be represented without underflow.
!>

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 98 of file dla_small_solve4.f90.

🌈 `subroutine dla_small_solve8` 🌈

subroutine dla_small_solve8 (integer n, double precision, dimension( 8, 8 )
    a, double precision, dimension(8) rhs, integer info, double precision
    eps, double precision smlnum)

Solver for 8-by-8 Linear Systems.

Purpose:

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

Parameters

N

!>          N is INTEGER
!>          The order of the matrix A  N = {1,2,4,8} .
!>

A

!>          A is DOUBLE PRECISION 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.
!>

💀 yes bestie, it says 4-by-4 in the 8-by-8 routine's docs. we are reporting, not fixing. that's the assignment. 🫶

RHS

!>          RHS is DOUBLE PRECISION array, dimension (8)
!>          The matrix RHS contains the right hand side on input and the solution X on output if INFO == 0
!>

INFO

!>          INFO is 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

!>          EPS is DOUBLE PRECISION
!>          EPS is the machine epsilon determined by DLAMCH
!>

SMLNUM

!>          SMLNUM is DOUBLE PRECISION
!>          SMLNUM is the smallest number in DOUBLE PRECISION which can be represented without underflow.
!>

Author

Martin Koehler, MPI Magdeburg

Date

October 2025

Definition at line 98 of file dla_small_solve8.f90.

✨ and that's part 1 bestie, hold on, there's more coming ✨

`subroutine dla_sort_ev` 💅

subroutine dla_sort_ev (integer n, double precision, dimension( lda, * ) a,
    integer lda, double precision, dimension( ldq, * ) q, integer ldq,
    integer nb, double precision, dimension( * ) work, integer info)

Block Reordering of generalized Eigenvalues. ✨

✨ Purpose ✨

Bestie, this one reorders the eigenvalues of a matrix A so that the complex eigenvalue pairs won't cause a change of the block size in blocked linear matrix equation solver codes. It uses DTREXC from LAPACK for moving the eigenvalues on the diagonal. No cap. 🔥

🎀 Parameters 🎀

N — INTEGER, gorgeous. It's the order of the matrices A and Q, and N >= 0. 💖
A — DOUBLE PRECISION 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 in A(k*NB,k*NB), where k is a non-negative integer. 🦋
LDA — INTEGER. It's the leading dimension of the array A. LDA >= MAX(1,N). ✨
Q — DOUBLE PRECISION 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. It's the leading dimension of the array Q. LDQ >= MAX(1,N). 🌸
NB — INTEGER. It's the 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 DTGEX2 caused an error. ]

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 124 of file dla_sort_ev.f90.

`subroutine dla_sort_gev` 👑

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

Block Reordering of generalized Eigenvalues. ✨

✨ Purpose ✨

This one reorders the eigenvalues of a matrix pencil (A,B) so that the complex eigenvalue pairs won't cause a change of the block size in blocked linear matrix equation solver codes. It uses DTGEX2 from LAPACK for moving the eigenvalues on the diagonal. Periodt. 💅

🎀 Parameters 🎀

N — INTEGER. The order of the matrices A, B, Q, and Z, N >= 0. 💖
A — DOUBLE PRECISION 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 in 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 — DOUBLE PRECISION 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 — DOUBLE PRECISION 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 — DOUBLE PRECISION 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. The 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 DTGEX2 caused an error. ]

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 165 of file dla_sort_gev.f90.

`subroutine dla_transform_general` 🧚

subroutine dla_transform_general (character, dimension(*) trans, integer m,
    integer n, double precision, dimension(ldx, *) x, integer ldx, double
    precision, dimension(ldqa, *) qa, integer ldqa, double precision,
    dimension(ldqb, *) qb, integer ldqb, double precision, dimension(*)
    work)

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

✨ Purpose ✨

DLA_TRANSFORM_STANDARD computes either

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

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. (Yes, bestie, it says DLA_TRANSFORM_STANDARD even though the subroutine is dla_transform_general — we don't make the rules, we just keep the details.) 💅

📝 Remarks

The function does not perform any check on the input arguments. So you better be sure, okay? 🙈

🎀 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 — DOUBLE PRECISION 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 — DOUBLE PRECISION 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 — DOUBLE PRECISION 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 — DOUBLE PRECISION array, dimension (M*N). Workspace for the computation. 🔥

Author: Martin Koehler, MPI Magdeburg

Date: October 2025

Definition at line 119 of file dla_transform_general.f90.

`subroutine dla_transform_standard` 🌟

subroutine dla_transform_standard (character, dimension(*) trans, integer m,
    double precision, dimension(ldx, *) x, integer ldx, double precision,
    dimension(ldq, *) q, integer ldq, double precision, dimension(*) work)

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

✨ Purpose ✨

DLA_TRANSFORM_STANDARD computes either

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

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 you better be sure, okay? 🙈

🎀 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 —
X — ok so X is a DOUBLE PRECISION array, dimension (LDX,M) 💖 and the matrix X is a general M-by-M matrix that gets overwritten by (1) or (2). yeah she's not surviving this one bestie, she's getting replaced 🫶
LDX — LDX is INTEGER</>, the leading dimension of the array X. and the rule is LDX >= max(1,M) ✨ no exceptions, she's gotta be big enough.
Q — Q is a DOUBLE PRECISION array, dimension (LDQ,M), and the matrix Q is M-by-M, the transformation matrix 👑 that's literally her whole job.
LDQ — LDQ is INTEGER</>, the leading dimension of the array Q. same energy: LDQ >= max(1,M) 💅
WORK — WORK is a DOUBLE PRECISION array, dimension (M**2), and it's the workspace for the computation. she does not get to be pretty, she gets to be useful 🎀

✍️ Author

Martin Koehler, MPI Magdeburg 🌸

📅 Date

October 2025 🦋

Definition at line 101 of file dla_transform_standard.f90. like, the receipts are right there iykyk 🔥

👑 Author

Generated automatically by Doxygen for MEPACK from the source code. not a human typing this out with love, a whole robot did it 😭 iconic behaviour honestly.

okay bestie that's the whole page, we're DONE ✨ no cap, you just read an entire Fortran linear algebra manpage and you ate. this one's from Version 1.1.2, stamped Thu Oct 9 2025 00:00:00, and it's dblaux(3) — go forth and call your functions responsibly, mwah 💖💅🦋

📦 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

dblaux(3)

🌸 dblaux(3) — MEPACK 💖

✨ NAME ✨

✨ SYNOPSIS ✨

🎀 Functions

✨ Detailed Description ✨

✨ Function Documentation ✨

🌈 subroutine dla_itranspose 🌈

Purpose:

Parameters

Author

Date

🌈 subroutine dla_qtrmm2 🌈

Purpose:

Parameters

Author

Date

🌈 subroutine dla_small_solve4 🌈

Purpose:

Parameters

Author

Date

🌈 subroutine dla_small_solve8 🌈

Purpose:

Parameters

Author

Date

subroutine dla_sort_ev 💅

✨ Purpose ✨

🎀 Parameters 🎀

subroutine dla_sort_gev 👑

✨ Purpose ✨

🎀 Parameters 🎀

subroutine dla_transform_general 🧚

✨ Purpose ✨

📝 Remarks

🎀 Parameters 🎀

subroutine dla_transform_standard 🌟

✨ Purpose ✨

📝 Remarks

🎀 Parameters 🎀

✍️ Author

📅 Date

👑 Author

🌈 `subroutine dla_itranspose` 🌈

🌈 `subroutine dla_qtrmm2` 🌈

🌈 `subroutine dla_small_solve4` 🌈

🌈 `subroutine dla_small_solve8` 🌈

`subroutine dla_sort_ev` 💅

`subroutine dla_sort_gev` 👑

`subroutine dla_transform_general` 🧚

`subroutine dla_transform_standard` 🌟