--- name: "geqr" 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/geqr" --- # geqr(3) geqr: QR factor, flexible ## NAME geqr - geqr: QR factor, flexible ## SYNOPSIS ### Functions subroutine **cgeqr** (m, n, a, lda, t, tsize, work, lwork, info)\ **CGEQR** subroutine **dgeqr** (m, n, a, lda, t, tsize, work, lwork, info)\ **DGEQR** subroutine **sgeqr** (m, n, a, lda, t, tsize, work, lwork, info)\ **SGEQR** subroutine **zgeqr** (m, n, a, lda, t, tsize, work, lwork, info)\ **ZGEQR** ## Detailed Description ## Function Documentation ### subroutine cgeqr (integer m, integer n, complex, dimension( lda, \* ) a, integer lda, complex, dimension( \* ) t, integer tsize, complex, dimension( \* ) work, integer lwork, integer info) **CGEQR** **Purpose:** ``` !> !> CGEQR computes a QR factorization of a complex M-by-N matrix A: !> !> A = Q * ( R ), !> ( 0 ) !> !> where: !> !> Q is a M-by-M orthogonal matrix; !> R is an upper-triangular N-by-N matrix; !> 0 is a (M-N)-by-N 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 above the diagonal of the array !> contain the min(M,N)-by-N upper trapezoidal matrix R !> (R is upper triangular if M >= N); !> the elements below 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 QR factorization algorithm they wish. The triangular !> (trapezoidal) R has to be stored in the upper 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 !> CLATSQR or CGEQRT !> !> Depending on the matrix dimensions M and N, and row and column !> block sizes MB and NB returned by ILAENV, CGEQR will use either !> CLATSQR (if the matrix is tall-and-skinny) or CGEQRT to compute !> the QR factorization. !> !> ``` Definition at line **174** of file **cgeqr.f**. ### subroutine dgeqr (integer m, integer n, double precision, dimension( lda, \* ) a, integer lda, double precision, dimension( \* ) t, integer tsize, double precision, dimension( \* ) work, integer lwork, integer info) **DGEQR** **Purpose:** ``` !> !> DGEQR computes a QR factorization of a real M-by-N matrix A: !> !> A = Q * ( R ), !> ( 0 ) !> !> where: !> !> Q is a M-by-M orthogonal matrix; !> R is an upper-triangular N-by-N matrix; !> 0 is a (M-N)-by-N 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 DOUBLE PRECISION array, dimension (LDA,N) !> On entry, the M-by-N matrix A. !> On exit, the elements on and above the diagonal of the array !> contain the min(M,N)-by-N upper trapezoidal matrix R !> (R is upper triangular if M >= N); !> the elements below 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 DOUBLE PRECISION 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) DOUBLE PRECISION 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 QR factorization algorithm they wish. The triangular !> (trapezoidal) R has to be stored in the upper 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 !> DLATSQR or DGEQRT !> !> Depending on the matrix dimensions M and N, and row and column !> block sizes MB and NB returned by ILAENV, DGEQR will use either !> DLATSQR (if the matrix is tall-and-skinny) or DGEQRT to compute !> the QR factorization. !> !> ``` Definition at line **174** of file **dgeqr.f**. ### subroutine sgeqr (integer m, integer n, real, dimension( lda, \* ) a, integer lda, real, dimension( \* ) t, integer tsize, real, dimension( \* ) work, integer lwork, integer info) **SGEQR** **Purpose:** ``` !> !> SGEQR computes a QR factorization of a real M-by-N matrix A: !> !> A = Q * ( R ), !> ( 0 ) !> !> where: !> !> Q is a M-by-M orthogonal matrix; !> R is an upper-triangular N-by-N matrix; !> 0 is a (M-N)-by-N 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 REAL array, dimension (LDA,N) !> On entry, the M-by-N matrix A. !> On exit, the elements on and above the diagonal of the array !> contain the min(M,N)-by-N upper trapezoidal matrix R !> (R is upper triangular if M >= N); !> the elements below 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 REAL 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) REAL 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 QR factorization algorithm they wish. The triangular !> (trapezoidal) R has to be stored in the upper 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 !> SLATSQR or SGEQRT !> !> Depending on the matrix dimensions M and N, and row and column !> block sizes MB and NB returned by ILAENV, SGEQR will use either !> SLATSQR (if the matrix is tall-and-skinny) or SGEQRT to compute !> the QR factorization. !> !> ``` Definition at line **174** of file **sgeqr.f**. ### subroutine zgeqr (integer m, integer n, complex\*16, dimension( lda, \* ) a, integer lda, complex\*16, dimension( \* ) t, integer tsize, complex\*16, dimension( \* ) work, integer lwork, integer info) **ZGEQR** **Purpose:** ``` !> !> ZGEQR computes a QR factorization of a complex M-by-N matrix A: !> !> A = Q * ( R ), !> ( 0 ) !> !> where: !> !> Q is a M-by-M orthogonal matrix; !> R is an upper-triangular N-by-N matrix; !> 0 is a (M-N)-by-N 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*16 array, dimension (LDA,N) !> On entry, the M-by-N matrix A. !> On exit, the elements on and above the diagonal of the array !> contain the min(M,N)-by-N upper trapezoidal matrix R !> (R is upper triangular if M >= N); !> the elements below 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*16 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*16 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 QR factorization algorithm they wish. The triangular !> (trapezoidal) R has to be stored in the upper 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 !> ZLATSQR or ZGEQRT !> !> Depending on the matrix dimensions M and N, and row and column !> block sizes MB and NB returned by ILAENV, ZGEQR will use either !> ZLATSQR (if the matrix is tall-and-skinny) or ZGEQRT to compute !> the QR factorization. !> !> ``` Definition at line **174** of file **zgeqr.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.