---
name: "cgelq.f"
section: "3"
platform: "linux"
package: "lapack-doc"
version: "3.12.1-2"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/cgelq.f"
---

# cgelq.f(3)

## NAME

SRC/cgelq.f

## SYNOPSIS

### Functions/Subroutines

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

## 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**

**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.
!>
!>
```

**Parameters**

*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 A.  N >= 0.
!>
```

*A*

```
!>          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.  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.
!>          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, 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.
!>
```

*LWORK*

```
!>          LWORK is INTEGER
!>          The dimension of the array WORK. LWORK >= 1.
!>          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
!>          = 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**

```
!>
!> 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.
!>
!>
```

**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.
!>
```

Definition at line **172** of file **cgelq.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.