gemlq(3)

📦

version 3.12.1 · 9 versions

3.12.1 · arch rolling (latest)
3.12.0 · opensuse-leap 16.0
3.12.1 · ubuntu stonking
3.12.1 · ubuntu questing
3.12.0 · ubuntu noble
3.12.0 · ubuntu noble
3.12.0 · centos-stream 10, fedora 43, fedora 44
3.12.1 · ubuntu resolute
3.12.1 · debian trixie

🌸 gemlq(3) — Library Functions Manual 🌸

okay bestie so this one is gemlq, straight out of section 3 (Library Functions Manual), and it's one of those LAPACK pages where you get the whole family in one go. Sit down, hydrate, we're doing this 💅

✨ NAME ✨

gemlq — gemlq: multiply by Q from gelq 🌀

✨ SYNOPSIS ✨

Functions

Four subroutines, one for each flavour. Not me getting four whole routines 😭 every precision got its own:

subroutine cgemlq (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) — CGEMLQ
subroutine dgemlq (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) — DGEMLQ
subroutine sgemlq (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) — SGEMLQ
subroutine zgemlq (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) — ZGEMLQ

✨ Detailed Description ✨

so this heading exists in the original and under it there is… nothing. zero. a whole void. it's giving empty group chat at 3am 💀 not a single crumb of content here, so we move straight to the good part.

💖 Function Documentation 💖

`subroutine cgemlq`

subroutine cgemlq (character side, character trans, integer m, integer n,
    integer k, complex, dimension( lda, * ) a, integer lda, complex,
    dimension( * ) t, integer tsize, complex, dimension( ldc, * ) c, integer
    ldc, complex, dimension( * ) work, integer lwork, integer info)

CGEMLQ 👑

Purpose

okay so here's the whole vibe: CGEMLQ overwrites the general real M-by-N matrix C with 👇

                     SIDE = 'L'     SIDE = 'R'
     TRANS = 'N':      Q * C          C * Q
     TRANS = 'C':      Q**H * C       C * Q**H

where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (CGELQ) ✨

(yes the original says "general real M-by-N matrix C" on a complex routine. we are simply not going to unpack that, bestie. moving on 🫶)

Parameters

SIDE — SIDE is CHARACTER*1. = 'L': apply Q or Q**H from the Left; = 'R': apply Q or Q**H from the Right. pick a side, any side 💅
TRANS — TRANS is CHARACTER*1. = 'N': no transpose, apply Q; = 'C': conjugate transpose, apply Q**H. that's the whole thing, no 'T' option here okurrr
M — M is INTEGER. The number of rows of the matrix A. M >=0. 📏
N — N is INTEGER. The number of columns of the matrix C. N >= 0. the way M is about A and N is about C… that's just how it is, bestie, don't @ me
K — K is INTEGER. The number of elementary reflectors whose product defines the matrix Q. If SIDE = 'L', M >= K >= 0; if SIDE = 'R', N >= K >= 0. so K is squeezed between zero and whichever dimension is relevant 🎀
A — A is COMPLEX array, dimension (LDA,M) if SIDE = 'L', (LDA,N) if SIDE = 'R'. Part of the data structure to represent Q as returned by CGELQ. it's not the whole Q, it's a part of it, respect the lore 📦
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,K). ⭐
T — T is COMPLEX array, dimension (MAX(5,TSIZE)). Part of the data structure to represent Q as returned by CGELQ. again, just a piece of the puzzle 🧩
TSIZE — TSIZE is INTEGER. The dimension of the array T. TSIZE >= 5. no vowel, no mercy 🦋
C — C is COMPLEX array, dimension (LDC,N). On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q. overwritten, so if you needed the old C… she's gone, bestie 😭
LDC — LDC is INTEGER. The leading dimension of the array C. LDC >= max(1,M). 💫
WORK — (workspace) COMPLEX array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the minimal LWORK. ✨
LWORK — LWORK is INTEGER. The dimension of the array WORK. LWORK >= 1. If LWORK = -1, then a workspace query is assumed: the routine only calculates the size of the WORK array, returns this value as WORK(1), and no error message related to WORK is issued by XERBLA. (that's the classic "lemme just ask how much room I need" move 🫶)
INFO — INFO is INTEGER. = 0: successful exit 🎉; < 0: if INFO = -i, the i-th argument had an illegal value 🚨

Author

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Further Details

⚠️ read this part, it's the fine print. These details are particular for this LAPACK implementation. Users should not take them for granted. These details may change in the future, and are not likely true for another LAPACK implementation. These details are relevant if one wants to try to understand the code. They are not part of the interface. 🫧

In this version 👇

T(2): row block size (MB)
T(3): column block size (NB)
T(6:TSIZE): data structure needed for Q, computed by
                 CLASWQR or CGELQT

Depending on the matrix dimensions M and N, and row and column block sizes MB and NB returned by ILAENV, CGELQ will use either CLASWLQ (if the matrix is wide-and-short) or CGELQT to compute the LQ factorization. This version of CGEMLQ will use either CLAMSWLQ or CGEMLQT to multiply matrix Q by another matrix. Further Details in CLAMSWLQ or CGEMLQT. 🔍

Definition at line 171 of file cgemlq.f.

`subroutine dgemlq`

subroutine dgemlq (character side, character trans, integer m, integer n,
    integer k, double precision, dimension( lda, * ) a, integer lda, double
    precision, dimension( * ) t, integer tsize, double precision, dimension(
    ldc, * ) c, integer ldc, double precision, dimension( * ) work, integer
    lwork, integer info)

DGEMLQ ✨

Purpose

DGEMLQ overwrites the general real M-by-N matrix C with 👇

                   SIDE = 'L'     SIDE = 'R'
   TRANS = 'N':      Q * C          C * Q
   TRANS = 'T':      Q**T * C       C * Q**T

where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (DGELQ) 🌈

Parameters

SIDE — SIDE is CHARACTER*1. = 'L': apply Q or Q**T from the Left; = 'R': apply Q or Q**T from the Right. 💅
TRANS — TRANS is CHARACTER*1. = 'N': no transpose, apply Q; = 'T': transpose, apply Q**T. (real precision, so no conjugation business — it's 'T' here, not 'C', and that's the whole difference bestie 🔥)
M — M is INTEGER. The number of rows of the matrix A. M >=0. 📏
N — N is INTEGER. The number of columns of the matrix C. N >= 0. 📐
K — K is INTEGER. The number of elementary reflectors whose product defines the matrix Q. If SIDE = 'L', M >= K >= 0; if SIDE = 'R', N >= K >= 0. 🎀
A — A is DOUBLE PRECISION array, dimension (LDA,M) if SIDE = 'L', (LDA,N) if SIDE = 'R'. Part of the data structure to represent Q as returned by DGELQ. 🧊
LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,K). ⭐
T — T is DOUBLE PRECISION array, dimension (MAX(5,TSIZE)). Part of the data structure to represent Q as returned by DGELQ. 🧩
TSIZE — TSIZE is INTEGER. The dimension of the array T. TSIZE >= 5. 🦋
C — C is DOUBLE PRECISION array, dimension (LDC,N). On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q. overwritten, babes, gone forever 😭
LDC — LDC is INTEGER. The leading dimension of the array C. LDC >= max(1,M). 💫
WORK — (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the minimal LWORK. ✨
LWORK — LWORK is INTEGER. The dimension of the array WORK. LWORK >= 1. If LWORK = -1, then a workspace query is assumed: the routine only calculates the size of the WORK array, returns this value as WORK(1), and no error message related to WORK is issued by XERBLA. 🫶
INFO — INFO is INTEGER. = 0: successful exit 🎉; < 0: if INFO = -i, the i-th argument had an illegal value 🚨

Author

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Further Details

⚠️ same warning as above, and it matters: These details are particular for this LAPACK implementation. Users should not take them for granted. These details may change in the future, and are not likely true for another LAPACK implementation. These details are relevant if one wants to try to understand the code. They are not part of the interface. 🫧

In this version 👇

T(2): row block size (MB)
T(3): column block size (NB)
T(6:TSIZE): data structure needed for Q, computed by
                 DLASWLQ or DGELQT

Depending on the matrix dimensions M and N, and row and column block sizes MB and NB returned by ILAENV, DGELQ will use either DLASWLQ (if the matrix is wide-and-short) or DGELQT to compute the LQ factorization. This version of DGEMLQ will use either DLAMSWLQ or DGEMLQT to multiply matrix Q by another matrix. Further Details in DLAMSWLQ or DGEMLQT. 🔍

Definition at line 172 of file dgemlq.f.

`subroutine sgemlq`

subroutine sgemlq (character side, character trans, integer m, integer n,
    integer k, real, dimension( lda, * ) a, integer lda, real, dimension( *
    ) t, integer tsize, real, dimension( ldc, * ) c, integer ldc, real,
    dimension( * ) work, integer lwork, integer info)

SGEMLQ 🌸

Purpose

SGEMLQ overwrites the general real M-by-N matrix C with 👇

                   SIDE = 'L'     SIDE = 'R'
   TRANS = 'N':      Q * C          C * Q
   TRANS = 'T':      Q**T * C       C * Q**T

where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (SGELQ) 🌷

Parameters

SIDE — bestie the page literally cuts off right here mid-parameter, so SIDE is where we're picking back up…
SIDE — a CHARACTER*1 bestie, okay? Which side are we multiplying from?
- = 'L' → apply Q or Q**T from the Left 🫶
- = 'R' → apply Q or Q**T from the Right
TRANS — also CHARACTER*1, the vibe check on transposition 💅
- = 'N' → No transpose, just apply Q
- = 'T' → Transpose, apply Q**T
M — INTEGER, the number of rows of the matrix A. Constraint era: M >= 0 ⭐
N — INTEGER, the number of columns of the matrix C. Also N >= 0, no cap 🧚
K — INTEGER, the number of elementary reflectors whose product defines the matrix Q. And the bounds are:
- If SIDE = 'L', then M >= K >= 0
- if SIDE = 'R', then N >= K >= 0
A — REAL array, dimension

                              (LDA,M) if SIDE = 'L',
                              (LDA,N) if SIDE = 'R'

Part of the data structure to represent Q as returned by SGELQ. It's literally part of Q's whole personality 🔥

LDA — INTEGER, the leading dimension of the array A. LDA >= max(1,K), respectfully 🙏
T — REAL array, dimension (MAX(5,TSIZE)). Part of the data structure to represent Q as returned by SGELQ. Same squad, different array 💜
TSIZE — INTEGER, the dimension of the array T. TSIZE >= 5, minimum requirement, we don't make the rules 🎀
C — REAL array, dimension (LDC,N). On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q. She gets a whole glow-up on the way out ✨
LDC — INTEGER, the leading dimension of the array C. LDC >= max(1,M) 👑
WORK — (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK)). Yes bestie, DOUBLE PRECISION — that's not a typo, that's literally what it says. On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
LWORK — INTEGER, the dimension of the array WORK. LWORK >= 1. And the fun part: if LWORK = -1, then a workspace query is assumed. The routine only calculates the size of the WORK array, returns this value as WORK(1), and no error message related to WORK is issued by XERBLA 😌
INFO — INTEGER, the receipts 📋
- = 0: successful exit 🎉
- < 0: if INFO = -i, the i-th argument had an illegal value 💀

Author

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Further Details

These details are particular for this LAPACK implementation. Users should not take them for granted. These details may change in the future, and are not likely true for another LAPACK implementation. These details are relevant if one wants to try to understand the code. They are not part of the interface. 🚨

In this version,

       T(2): row block size (MB)
       T(3): column block size (NB)
       T(6:TSIZE): data structure needed for Q, computed by
                        SLASWLQ or SGELQT

Depending on the matrix dimensions M and N, and row and column block sizes MB and NB returned by ILAENV, SGELQ will use either SLASWLQ (if the matrix is wide-and-short) or SGELQT to compute the LQ factorization.

This version of SGEMLQ will use either SLAMSWLQ or SGEMLQT to multiply matrix Q by another matrix.

Further Details in SLAMSWLQ or SGEMLQT 🦋

Definition at line 171 of file sgemlq.f.

🌈 subroutine zgemlq

subroutine zgemlq (character side, character trans, integer m, integer n,
    integer k, complex*16, dimension( lda, * ) a, integer lda, complex*16,
    dimension( * ) t, integer tsize, complex*16, dimension( ldc, * ) c,
    integer ldc, complex*16, dimension( * ) work, integer lwork, integer
    info)

ZGEMLQ — the complex flirty cousin, same energy, different dtype 💜✨

Purpose

ZGEMLQ overwrites the general real M-by-N matrix C with

                     SIDE = 'L'     SIDE = 'R'
TRANS = 'N':      Q * C          C * Q
TRANS = 'C':      Q**H * C       C * Q**H

where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by short wide LQ factorization (ZGELQ) 🔥🔥

Parameters

SIDE — CHARACTER*1, which side we're sliding in from 🫶
- = 'L' → apply Q or Q**H from the Left
- = 'R' → apply Q or Q**H from the Right
TRANS — CHARACTER*1, note it says 'C' this time, not 'T' — conjugate transposition is the whole point, iykyk 💅
- = 'N' → No transpose, apply Q
- = 'C' → Conjugate transpose, apply Q**H
M — INTEGER, the number of rows of the matrix A. M >= 0 ⭐
N — INTEGER, the number of columns of the matrix C. N >= 0 🌸
K — INTEGER, the number of elementary reflectors whose product defines the matrix Q. Bounds:
- If SIDE = 'L', then M >= K >= 0
- if SIDE = 'R', then N >= K >= 0
A — COMPLEX*16 array, dimension

                             (LDA,M) if SIDE = 'L',
                             (LDA,N) if SIDE = 'R'

Part of the data structure to represent Q as returned by ZGELQ 👑

LDA — INTEGER, the leading dimension of the array A. LDA >= max(1,K) 🙏
T — COMPLEX*16 array, dimension (MAX(5,TSIZE)). Part of the data structure to represent Q as returned by ZGELQ. Again. Still iconic 🎀
TSIZE — INTEGER, the dimension of the array T. TSIZE >= 5 💜
C — COMPLEX*16 array, dimension (LDC,N). On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q ✨
LDC — INTEGER, the leading dimension of the array C. LDC >= max(1,M) 🧚
WORK — (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the minimal LWORK ⭐
LWORK — INTEGER, the dimension of the array WORK. LWORK >= 1. If LWORK = -1, then a workspace query is assumed. The routine only calculates the size of the WORK array, returns this value as WORK(1), and no error message related to WORK is issued by XERBLA 😌
INFO — INTEGER, the receipts 📋
- = 0: successful exit 🎉
- < 0: if INFO = -i, the i-th argument had an illegal value 💀

Author

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Further Details

These details are particular for this LAPACK implementation. Users should not take them for granted. These details may change in the future, and are not likely true for another LAPACK implementation. These details are relevant if one wants to try to understand the code. They are not part of the interface. 🚨

In this version,

       T(2): row block size (MB)
       T(3): column block size (NB)
       T(6:TSIZE): data structure needed for Q, computed by
                        ZLASWLQ or ZGELQT

Depending on the matrix dimensions M and N, and row and column block sizes MB and NB returned by ILAENV, ZGELQ will use either ZLASWLQ (if the matrix is wide-and-short) or ZGELQT to compute the LQ factorization.

This version of ZGEMLQ will use either ZLAMSWLQ or ZGEMLQT to multiply matrix Q by another matrix.

Further Details in ZLAMSWLQ or ZGEMLQT 🌈

Definition at line 170 of file zgemlq.f.

🎀 Author

Generated automatically by Doxygen for LAPACK from the source code.

okay that's the whole page bestie, you made it to the end 🫶✨ this little beauty is from LAPACK Version 3.12.0, dated gemlq(3) — go forth and multiply your matrices, slay 💅👑

📦 where this page comes from

arch rolling: lapack-doc 3.12.1-2 · custom
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms