/home/abui...RC/cgelq.f(3)

📦 version 3.12.0, in opensuse-leap 16.0

✨ CGELQ ✨

Okay bestie, so this is the manual page for cgelq.f, which lives at .../lapack-static-3.12.0-build/lapack-3.12.0/SRC/cgelq.f — it's from the LAPACK Library Functions Manual and it's giving big linear algebra energy. 💅

SYNOPSIS

Functions/Subroutines

subroutine CGELQ (m, n, a, lda, t, tsize, work, lwork, info)

CGELQ is the main character, no cap. 👑

Function/Subroutine Documentation

subroutine CGELQ (integer m, integer n, complex, dimension( lda, * ) a,
    integer lda, complex, dimension( * ) t, integer tsize, complex,
    dimension( * ) work, integer lwork, integer info)

CGELQ — periodt.

Purpose

!> !> CGELQ computes an LQ factorization of a complex M-by-N matrix A: !> !> A = ( L 0 ) * Q !> !> where: !> !> Q is a N-by-N orthogonal matrix; !> L is a lower-triangular M-by-M matrix; !> 0 is a M-by-(N-M) zero matrix, if M < N. !> !>

Literal factorization slay. It's breaking your matrix A into ( L 0 ) * Q and honestly? Iconic. 🌸

Parameters

  • M — M is INTEGER, bestie. It's the number of rows of the matrix A, and it's gotta be M >= 0. No negative rows allowed, periodt. 🔥
!>          M is INTEGER
!>          The number of rows of the matrix A.  M >= 0.
!>
  • N — N is INTEGER. The number of columns of the matrix A, and N >= 0. Same energy, no negativity. 🦋
!>          N is INTEGER
!>          The number of columns of the matrix A.  N >= 0.
!>
  • A — A is COMPLEX array, dimension (LDA,N). On entry, it's the M-by-N matrix A. On exit? The elements on and below the diagonal of the array contain the M-by-min(M,N) lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the diagonal are used to store part of the data structure to represent Q. So A is literally doing double duty. We love a multitasking queen. 👑
!>          A is COMPLEX array, dimension (LDA,N)
!>          On entry, the M-by-N matrix A.
!>          On exit, the elements on and below the diagonal of the array
!>          contain the M-by-min(M,N) lower trapezoidal matrix L
!>          (L is lower triangular if M <= N);
!>          the elements above the diagonal are used to store part of the
!>          data structure to represent Q.
!>
  • LDA — LDA is INTEGER. The leading dimension of the array A. It's gotta be LDA >= max(1,M). Respect the leading dimension or else. 💅
!>          LDA is INTEGER
!>          The leading dimension of the array A.  LDA >= max(1,M).
!>
  • T — T is COMPLEX array, dimension (MAX(5,TSIZE)). On exit, if INFO = 0, T(1) returns optimal (or either minimal or optimal, if query is assumed) TSIZE. See TSIZE for details. The remaining T contains part of the data structure used to represent Q. If you wanna apply or construct Q, you need to keep T (in addition to A) and pass it to further subroutines. T is lowkey essential, don't lose her. 🎀
!>          T is COMPLEX array, dimension (MAX(5,TSIZE))
!>          On exit, if INFO = 0, T(1) returns optimal (or either minimal
!>          or optimal, if query is assumed) TSIZE. See TSIZE for details.
!>          Remaining T contains part of the data structure used to represent Q.
!>          If one wants to apply or construct Q, then one needs to keep T
!>          (in addition to A) and pass it to further subroutines.
!>
  • TSIZE — TSIZE is INTEGER. If TSIZE >= 5, it's the dimension of the array T. If TSIZE = -1 or -2, then a workspace query is assumed — the routine only calculates the sizes of the T and WORK arrays, returns these values as the first entries of the T and WORK arrays, and no error message related to T or WORK is issued by XERBLA. If TSIZE = -1, the routine calculates optimal size of T for optimum performance and returns this value in T(1). If TSIZE = -2, the routine calculates minimal size of T and returns this value in T(1). So -1 is giving "I want the best" and -2 is giving "just the minimum, I'm on a budget". 💀
!>          TSIZE is INTEGER
!>          If TSIZE >= 5, the dimension of the array T.
!>          If TSIZE = -1 or -2, then a workspace query is assumed. The routine
!>          only calculates the sizes of the T and WORK arrays, returns these
!>          values as the first entries of the T and WORK arrays, and no error
!>          message related to T or WORK is issued by XERBLA.
!>          If TSIZE = -1, the routine calculates optimal size of T for the
!>          optimum performance and returns this value in T(1).
!>          If TSIZE = -2, the routine calculates minimal size of T and
!>          returns this value in T(1).
!>
  • WORK — (workspace) COMPLEX array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) contains optimal (or either minimal or optimal, if query was assumed) LWORK. See LWORK for details. WORK is literally just here to help and then you can forget about her. 🙈
!>          (workspace) COMPLEX array, dimension (MAX(1,LWORK))
!>          On exit, if INFO = 0, WORK(1) contains optimal (or either minimal
!>          or optimal, if query was assumed) LWORK.
!>          See LWORK for details.
!>
  • LWORK — LWORK is INTEGER. The dimension of the array WORK. If LWORK = -1 or -2, then a workspace query is assumed. The routine only calculates the sizes of the T and WORK arrays, returns these values as the first entries of the T and WORK arrays, and no error message related to T or WORK is issued by XERBLA. If LWORK = -1, the routine calculates optimal size of WORK for optimal performance and returns this value in WORK(1). If LWORK = -2, the routine calculates minimal size of WORK and returns this value in WORK(1). Same -1 vs -2 energy as TSIZE, bestie. 🫶
!>          LWORK is INTEGER
!>          The dimension of the array WORK.
!>          If LWORK = -1 or -2, then a workspace query is assumed. The routine
!>          only calculates the sizes of the T and WORK arrays, returns these
!>          values as the first entries of the T and WORK arrays, and no error
!>          message related to T or WORK is issued by XERBLA.
!>          If LWORK = -1, the routine calculates optimal size of WORK for the
!>          optimal performance and returns this value in WORK(1).
!>          If LWORK = -2, the routine calculates minimal size of WORK and
!>          returns this value in WORK(1).
!>
  • INFO — INFO is INTEGER. The vibes check:
    • = 0: successful exit 🎉
    • < 0: if INFO = -i, the i-th argument had an illegal value. So negative INFO means someone messed up, not the routine. 😭
!>          INFO is INTEGER
!>          = 0:  successful exit
!>          < 0:  if INFO = -i, the i-th argument had an illegal value
!>

Author

Shoutout to the academic legends who made this happen:

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

Further Details

!> !> The goal of the interface is to give maximum freedom to the developers for !> creating any LQ factorization algorithm they wish. The triangular !> (trapezoidal) L has to be stored in the lower part of A. The lower part of A !> and the array T can be used to store any relevant information for applying or !> constructing the Q factor. The WORK array can safely be discarded after exit. !> !> Caution: One should not expect the sizes of T and WORK to be the same from one !> LAPACK implementation to the other, or even from one execution to the other. !> A workspace query (for T and WORK) is needed at each execution. However, !> for a given execution, the size of T and WORK are fixed and will not change !> from one query to the next. !> !>

The goal of this interface is literally maximum freedom for developers to create whatever LQ factorization algorithm they want. The triangular (trapezoidal) L has to be stored in the lower part of A. The lower part of A and the array T can be used to store any relevant information for applying or constructing the Q factor. The WORK array can safely be discarded after exit — she's just there for support, no strings attached. 💜

Caution, bestie: do not expect the sizes of T and WORK to be the same from one LAPACK implementation to the other, or even from one execution to the other. A workspace query (for T and WORK) is needed at each execution. However, for a given execution, the size of T and WORK are fixed and will not change from one query to the next. So like — query every time, but once you query, you're solid. 🫡

Further Details particular to this LAPACK implementation

!> !> 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 !> CLASWLQ 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 short-and-wide) or CGELQT to compute !> the LQ factorization. !>

Okay so these details are particular to this LAPACK implementation — do not take them for granted, they might change in the future, and they're probably not true for another LAPACK implementation. They're relevant if you wanna try to understand the code, but they're 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 CLASWLQ 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 short-and-wide) or CGELQT to compute the LQ factorization. So it's picking the right tool for the vibe of your matrix. 💅

Definition at line 172 of file cgelq.f.

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

LAPACK Version 3.12.0 — from /home/abui...RC/cgelq.f(3) — okay that's the whole page bestie, hope you slayed this LQ factorization understanding! 💖🌈👑

📦 where this page comes from