gghrd(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

🎀 `gghrd(3)` — reduction to Hessenberg 🎀

okay bestie, so this is gghrd(3) from the Library Functions Manual, and it's genuinely such a superstar page. It's not one function — it's a whole little squad of four: cgghrd, dgghrd, sgghrd, and zgghrd. Same energy, different precision. Let's get into it 💅✨

✨ NAME ✨

gghrd — gghrd: reduction to Hessenberg

🦋 SYNOPSIS 🦋

🌸 Functions

subroutine cgghrd (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) — CGGHRD
subroutine dgghrd (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) — DGGHRD
subroutine sgghrd (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) — SGGHRD
subroutine zgghrd (compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) — ZGGHRD

💖 Detailed Description 💖

so the page has this section, and then it gets into the individual function documentation. The actual tea is all down there in the function docs, bestie — keep scrolling 💜

🌈 Function Documentation 🌈

💜 subroutine `cgghrd` (`character compq`, `character compz`, `integer n`, `integer ilo`, `integer ihi`, `complex, dimension( lda, * ) a`, `integer lda`, `complex, dimension( ldb, * ) b`, `integer ldb`, `complex, dimension( ldq, * ) q`, `integer ldq`, `complex, dimension( ldz, * ) z`, `integer ldz`, `integer info`)

CGGHRD

subroutine cgghrd (character compq, character compz, integer n, integer ilo,
    integer ihi, complex, dimension( lda, * ) a, integer lda, complex,
    dimension( ldb, * ) b, integer ldb, complex, dimension( ldq, * ) q,
    integer ldq, complex, dimension( ldz, * ) z, integer ldz, integer info)

🔥 Purpose

okay so CGGHRD takes a pair of complex matrices (A,B) and reduces them to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is

   A*x = lambda*B*x,

and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation.

This subroutine simultaneously reduces A to a Hessenberg matrix H:

   Q**H*A*Z = H

and transforms B to another upper triangular matrix T:

   Q**H*B*Z = T

in order to reduce the problem to its standard form

   H*y = lambda*T*y

where y = Z**H*x.

The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that

      Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H
      Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H

If Q1 is the unitary matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then CGGHRD reduces the original problem to generalized Hessenberg form.

🌟 Parameters

COMPQ — COMPQ is CHARACTER*1
- = 'N': do not compute Q;
- = 'I': Q is initialized to the unit matrix, and the unitary matrix Q is returned;
- = 'V': Q must contain a unitary matrix Q1 on entry, and the product Q1*Q is returned.
COMPZ — COMPZ is CHARACTER*1
- = 'N': do not compute Z;
- = 'I': Z is initialized to the unit matrix, and the unitary matrix Z is returned;
- = 'V': Z must contain a unitary matrix Z1 on entry, and the product Z1*Z is returned.
N — N is INTEGER. The order of the matrices A and B. N >= 0.
ILO — ILO is INTEGER
IHI — IHI is INTEGER

ILO and IHI mark the rows and columns of A which are to be reduced. It is assumed that A is already upper triangular in rows and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally set by a previous call to CGGBAL; otherwise they should be set to 1 and N respectively. 1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.

A — A is COMPLEX array, dimension (LDA, N)

On entry, the N-by-N general matrix to be reduced. On exit, the upper triangle and the first subdiagonal of A are overwritten with the upper Hessenberg matrix H, and the rest is set to zero.

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

On entry, the N-by-N upper triangular matrix B. On exit, the upper triangular matrix T = Q**H B Z. The elements below the diagonal are set to zero.

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

On entry, if COMPQ = 'V', the unitary matrix Q1, typically from the QR factorization of B. On exit, if COMPQ='I', the unitary matrix Q, and if COMPQ = 'V', the product Q1*Q. Not referenced if COMPQ='N'.

LDQ — LDQ is INTEGER. The leading dimension of the array Q. LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise.
Z — Z is COMPLEX array, dimension (LDZ, N)

On entry, if COMPZ = 'V', the unitary matrix Z1. On exit, if COMPZ='I', the unitary matrix Z, and if COMPZ = 'V', the product Z1*Z. Not referenced if COMPZ='N'.

LDZ — LDZ is INTEGER. The leading dimension of the array Z. LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise.
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

This routine reduces A to Hessenberg and B to triangular form by an unblocked reduction, as described in _Matrix_Computations_, by Golub and van Loan (Johns Hopkins Press).

Definition at line 202 of file cgghrd.f.

💙 subroutine `dgghrd` (`character compq`, `character compz`, `integer n`, `integer ilo`, `integer ihi`, `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 info`)

DGGHRD

subroutine dgghrd (character compq, character compz, integer n, integer ilo,
    integer ihi, 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 info)

🔥 Purpose

okay so DGGHRD is the real-valued twin of the whole situation. It reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is

   A*x = lambda*B*x,

and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation.

This subroutine simultaneously reduces A to a Hessenberg matrix H:

   Q**T*A*Z = H

and transforms B to another upper triangular matrix T:

   Q**T*B*Z = T

in order to reduce the problem to its standard form

   H*y = lambda*T*y

where y = Z**T*x.

The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that

      Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T

      Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T

If Q1 is the orthogonal matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then DGGHRD reduces the original problem to generalized Hessenberg form.

🌟 Parameters

COMPQ — COMPQ is CHARACTER*1
- = 'N': do not compute Q;
- = 'I': Q is initialized to the unit matrix, and the orthogonal matrix Q is returned;
- = 'V': Q must contain an orthogonal matrix Q1 on entry, and the product Q1*Q is returned.
COMPZ — COMPZ is CHARACTER*1
- = 'N': do not compute Z;
- = 'I': Z is initialized to the unit matrix, and the orthogonal matrix Z is returned;
- = 'V': Z must contain an orthogonal matrix Z1 on entry, and the product Z1*Z is returned.
N — N is INTEGER. The order of the matrices A and B. N >= 0.
ILO — ILO is INTEGER
IHI — IHI is INTEGER

ILO and IHI mark the rows and columns of A which are to be reduced. It is assumed that A is already upper triangular in rows and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally set by a previous call to DGGBAL; otherwise they should be set to 1 and N respectively. 1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.

A — A is DOUBLE PRECISION array, dimension (LDA, N)

On entry, the N-by-N general matrix to be reduced. On exit, the upper triangle and the first subdiagonal of A are overwritten with the upper Hessenberg matrix H, and the rest is set to zero.

LDA — LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,N).
B — B is DOUBLE PRECISION array, dimension (LDB, N)

On entry, the N-by-N upper triangular matrix B. On exit, the upper triangular matrix T = Q**T B Z. The elements below the diagonal are set to zero.

LDB — LDB is INTEGER. The leading dimension of the array B. LDB >= max(1,N).
Q — Q is DOUBLE PRECISION array, dimension (LDQ, N)

On entry, if COMPQ = 'V', the orthogonal matrix Q1, typically from the QR factorization of B. On exit, if COMPQ='I', the orthogonal matrix Q, and if COMPQ = 'V', the product Q1*Q. Not referenced if COMPQ='N'.

LDQ — LDQ is INTEGER. The leading dimension of the array Q. LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise.
Z —
Z — DOUBLE PRECISION array, dimension (LDZ, N). On entry, if COMPZ = 'V', she's holding the orthogonal matrix Z1. On exit, if COMPZ = 'I', she is the orthogonal matrix Z, and if COMPZ = 'V', she's the product Z1*Z. Not referenced at all if COMPZ = 'N' — she's literally not in the group chat. 🦋
LDZ — INTEGER. The leading dimension of the array Z. LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise. Respect the rules bestie. ✨
INFO — INTEGER, the vibe report:
- = 0: successful exit, we ate, no crumbs. 💅
- < 0: if INFO = -i, the i-th argument had an illegal value. 😭 somebody fumbled the call.

👑 Author 👑

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

📖 Further Details: 📖

This routine reduces A to Hessenberg and B to triangular form by an unblocked reduction, as described in Matrix Computations, by Golub and Van Loan (Johns Hopkins Press.) 💜

📍 Definition at line 205 of file dgghrd.f.

💅 `sgghrd` 💅

subroutine sgghrd (character compq, character compz, integer n, integer ilo,
    integer ihi, 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 info)

Bestie. SGGHRD is the real single-precision one. Same job, smaller floats, same main character energy.

🎯 Purpose 🎯

SGGHRD reduces a pair of real matrices (A,B) to generalized upper Hessenberg form using orthogonal transformations, where A is a general matrix and B is upper triangular. 👑

The generalized eigenvalue problem shows up looking like this:

A*x = lambda*B*x

and B is typically made upper triangular by computing its QR factorization and moving the orthogonal matrix Q to the left side of the equation. Classic glow-up. ✨

This subroutine simultaneously reduces A to a Hessenberg matrix H:

Q**T*A*Z = H

and transforms B to another upper triangular matrix T:

Q**T*B*Z = T

so the problem drops into its standard form:

H*y = lambda*T*y

where y = Z**T*x. Cute, right? 🫶

The orthogonal matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that

Q1 * A * Z1**T = (Q1*Q) * H * (Z1*Z)**T

Q1 * B * Z1**T = (Q1*Q) * T * (Z1*Z)**T

If Q1 is the orthogonal matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then SGGHRD reduces the original problem to generalized Hessenberg form. No cap. 💯

🌈 Parameters 🌈

COMPQ — CHARACTER*1, pick your fighter:
- = 'N': do not compute Q. 🙈
- = 'I': Q is initialized to the unit matrix, and the orthogonal matrix Q is returned.
- = 'V': Q must contain an orthogonal matrix Q1 on entry, and the product Q1*Q is returned.
COMPZ — CHARACTER*1, same energy but for Z:
- = 'N': do not compute Z.
- = 'I': Z is initialized to the unit matrix, and the orthogonal matrix Z is returned.
- = 'V': Z must contain an orthogonal matrix Z1 on entry, and the product Z1*Z is returned.
N — INTEGER. The order of the matrices A and B. N >= 0. 🍓
ILO — INTEGER. Just vibing here on its own, see IHI. ⭐
IHI — INTEGER. ILO and IHI mark the rows and columns of A which are to be reduced. It is assumed that A is already upper triangular in rows and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally set by a previous call to SGGBAL; otherwise they should be set to 1 and N respectively. And the constraint, bestie: 1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0. 🔥
A — REAL array, dimension (LDA, N). On entry, the N-by-N general matrix to be reduced. On exit, the upper triangle and the first subdiagonal of A are overwritten with the upper Hessenberg matrix H, and the rest is set to zero. She gets a whole makeover and the leftovers get cleared. 💅
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,N). 🎀
B — REAL array, dimension (LDB, N). On entry, the N-by-N upper triangular matrix B. On exit, the upper triangular matrix T = Q**T B Z. The elements below the diagonal are set to zero. 🙈
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N). 🧚
Q — REAL array, dimension (LDQ, N). On entry, if COMPQ = 'V', the orthogonal matrix Q1, typically from the QR factorization of B. On exit, if COMPQ='I', the orthogonal matrix Q, and if COMPQ = 'V', the product Q1*Q. Not referenced if COMPQ='N'. 💜
LDQ — INTEGER. The leading dimension of the array Q. LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise. ✨
Z — REAL array, dimension (LDZ, N). On entry, if COMPZ = 'V', the orthogonal matrix Z1. On exit, if COMPZ='I', the orthogonal matrix Z, and if COMPZ = 'V', the product Z1*Z. Not referenced if COMPZ='N'. 🦋
LDZ — INTEGER. The leading dimension of the array Z. LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise. 🌸
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: 📖

This routine reduces A to Hessenberg and B to triangular form by an unblocked reduction, as described in Matrix Computations, by Golub and Van Loan (Johns Hopkins Press.) 📚

📍 Definition at line 205 of file sgghrd.f.

💜 `zgghrd` 💜

subroutine zgghrd (character compq, character compz, integer n, integer ilo,
    integer ihi, complex*16, dimension( lda, * ) a, integer lda, complex*16,
    dimension( ldb, * ) b, integer ldb, complex*16, dimension( ldq, * ) q,
    integer ldq, complex*16, dimension( ldz, * ) z, integer ldz, integer
    info)

Now the complex*16 one — ZGGHRD. Same plot, but everything is unitary instead of orthogonal and we're conjugating-transposing with **H. She's the double-precision complex main character. 👑

🎯 Purpose 🎯

ZGGHRD reduces a pair of complex matrices (A,B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular. The form of the generalized eigenvalue problem is

A*x = lambda*B*x

and B is typically made upper triangular by computing its QR factorization and moving the unitary matrix Q to the left side of the equation. 🌈

This subroutine simultaneously reduces A to a Hessenberg matrix H:

Q**H*A*Z = H

and transforms B to another upper triangular matrix T:

Q**H*B*Z = T

in order to reduce the problem to its standard form:

H*y = lambda*T*y

where y = Z**H*x. 🫶

The unitary matrices Q and Z are determined as products of Givens rotations. They may either be formed explicitly, or they may be postmultiplied into input matrices Q1 and Z1, so that

Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H

Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H

If Q1 is the unitary matrix from the QR factorization of B in the original equation A*x = lambda*B*x, then ZGGHRD reduces the original problem to generalized Hessenberg form. Periodt. 💅

🌈 Parameters 🌈

COMPQ — CHARACTER*1:
- = 'N': do not compute Q. 🙈
- = 'I': Q is initialized to the unit matrix, and the unitary matrix Q is returned.
- = 'V': Q must contain a unitary matrix Q1 on entry, and the product Q1*Q is returned.
COMPZ — CHARACTER*1:
- = 'N': do not compute Z.
- = 'I': Z is initialized to the unit matrix, and the unitary matrix Z is returned.
- = 'V': Z must contain a unitary matrix Z1 on entry, and the product Z1*Z is returned.
N — INTEGER. The order of the matrices A and B. N >= 0. 🍓
ILO — INTEGER. Hangs out with IHI, scroll a lil. ⭐
IHI — INTEGER. ILO and IHI mark the rows and columns of A which are to be reduced. It is assumed that A is already upper triangular in rows and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally set by a previous call to ZGGBAL; otherwise they should be set to 1 and N respectively. Constraints, no negotiating: 1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0. 🔥
A — COMPLEX*16 array, dimension (LDA, N). On entry, the N-by-N general matrix to be reduced. On exit, the upper triangle and the first subdiagonal of A are overwritten with the upper Hessenberg matrix H, and the rest is set to zero. ✨
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,N). 🎀
B — COMPLEX*16 array, dimension (LDB, N). On entry, the N-by-N upper triangular matrix B. On exit, the upper triangular matrix T = Q**H B Z. The elements below the diagonal are set to zero. 🙈
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,N). 🧚
Q
Q — Q is COMPLEX*16 array, dimension (LDQ, N). On entry, if COMPQ = 'V', it’s the unitary matrix Q1, typically from the QR factorization of B. On exit, if COMPQ='I', it’s the unitary matrix Q, and if COMPQ = 'V', it’s the product Q1*Q. Not referenced if COMPQ='N'. 💅
LDQ — LDQ is INTEGER. It’s the leading dimension of the array Q. LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise. 🎀
Z — Z is COMPLEX*16 array, dimension (LDZ, N). On entry, if COMPZ = 'V', it’s the unitary matrix Z1. On exit, if COMPZ='I', it’s the unitary matrix Z, and if COMPZ = 'V', it’s the product Z1*Z. Not referenced if COMPZ='N'. 🦋
LDZ — LDZ is INTEGER. It’s the leading dimension of the array Z. LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise. 🌸
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 🔍

This routine reduces A to Hessenberg and B to triangular form by an unblocked reduction, as described in Matrix_Computations_, by Golub and van Loan (Johns Hopkins Press). 📚

Definition at line 202 of file zgghrd.f.

👑 Author (page-level, Doxygen-made) 👑

Generated automatically by Doxygen for LAPACK from the source code. 🤖

okay bestie, that’s the whole page! Source/version deets: LAPACK Version 3.12.0, page gghrd(3). The footer doesn’t list a date, so consider that your cute little no-date sign-off 🫶✨

📦 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

gghrd(3)

🎀 gghrd(3) — reduction to Hessenberg 🎀

✨ NAME ✨

🦋 SYNOPSIS 🦋

🌸 Functions

💖 Detailed Description 💖

🌈 Function Documentation 🌈

💜 subroutine cgghrd (character compq, character compz, integer n, integer ilo, integer ihi, complex, dimension( lda, * ) a, integer lda, complex, dimension( ldb, * ) b, integer ldb, complex, dimension( ldq, * ) q, integer ldq, complex, dimension( ldz, * ) z, integer ldz, integer info)

🔥 Purpose

🌟 Parameters

💌 Author

🧚 Further Details

🔥 Purpose

🌟 Parameters

👑 Author 👑

📖 Further Details: 📖

💅 sgghrd 💅

🎯 Purpose 🎯

🌈 Parameters 🌈

👑 Author 👑

📖 Further Details: 📖

💜 zgghrd 💜

🎯 Purpose 🎯

🌈 Parameters 🌈

👑 Author 👑

🔍 Further Details 🔍

👑 Author (page-level, Doxygen-made) 👑

🎀 `gghrd(3)` — reduction to Hessenberg 🎀

💅 `sgghrd` 💅

💜 `zgghrd` 💜