--- name: "gemqr" 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/gemqr" --- # gemqr(3) gemqr: multiply by Q from geqr ## NAME gemqr - gemqr: multiply by Q from geqr ## SYNOPSIS ### Functions subroutine **cgemqr** (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)\ **CGEMQR** subroutine **dgemqr** (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)\ **DGEMQR** subroutine **sgemqr** (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)\ **SGEMQR** subroutine **zgemqr** (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)\ **ZGEMQR** ## Detailed Description ## Function Documentation ### subroutine cgemqr (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) **CGEMQR** **Purpose:** ``` !> !> CGEMQR overwrites the general real M-by-N matrix C with !> !> SIDE = 'L' SIDE = 'R' !> TRANS = 'N': Q * C C * Q !> TRANS = 'T': Q**H * C C * Q**H !> !> where Q is a complex unitary matrix defined as the product !> of blocked elementary reflectors computed by tall skinny !> QR factorization (CGEQR) !> !> ``` **Parameters** *SIDE* ``` !> SIDE is CHARACTER*1 !> = 'L': apply Q or Q**H from the Left; !> = 'R': apply Q or Q**H from the Right. !> ``` *TRANS* ``` !> TRANS is CHARACTER*1 !> = 'N': No transpose, apply Q; !> = 'C': Conjugate transpose, apply Q**H. !> ``` *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 COMPLEX array, dimension (LDA,K) !> Part of the data structure to represent Q as returned by CGEQR. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. !> If SIDE = 'L', LDA >= max(1,M); !> if SIDE = 'R', LDA >= max(1,N). !> ``` *T* ``` !> T is COMPLEX array, dimension (MAX(5,TSIZE)). !> Part of the data structure to represent Q as returned by CGEQR. !> ``` *TSIZE* ``` !> TSIZE is INTEGER !> The dimension of the array T. TSIZE >= 5. !> ``` *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. !> ``` *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. !> ``` *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** ``` !> !> 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. !> This version of CGEMQR will use either CLAMTSQR or CGEMQRT to !> multiply matrix Q by another matrix. !> Further Details in CLAMTSQR or CGEMQRT. !> !> ``` Definition at line **173** of file **cgemqr.f**. ### subroutine dgemqr (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) **DGEMQR** **Purpose:** ``` !> !> DGEMQR 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 tall skinny !> QR factorization (DGEQR) !> !> ``` **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. !> ``` *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,K) !> Part of the data structure to represent Q as returned by DGEQR. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. !> If SIDE = 'L', LDA >= max(1,M); !> if SIDE = 'R', LDA >= max(1,N). !> ``` *T* ``` !> T is DOUBLE PRECISION array, dimension (MAX(5,TSIZE)). !> Part of the data structure to represent Q as returned by DGEQR. !> ``` *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. !> ``` *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** ``` !> !> 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. !> This version of DGEMQR will use either DLAMTSQR or DGEMQRT to !> multiply matrix Q by another matrix. !> Further Details in DLATMSQR or DGEMQRT. !> !> ``` Definition at line **173** of file **dgemqr.f**. ### subroutine sgemqr (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) **SGEMQR** **Purpose:** ``` !> !> SGEMQR 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 tall skinny !> QR factorization (SGEQR) !> !> ``` **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. !> ``` *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 REAL array, dimension (LDA,K) !> Part of the data structure to represent Q as returned by SGEQR. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. !> If SIDE = 'L', LDA >= max(1,M); !> if SIDE = 'R', LDA >= max(1,N). !> ``` *T* ``` !> T is REAL array, dimension (MAX(5,TSIZE)). !> Part of the data structure to represent Q as returned by SGEQR. !> ``` *TSIZE* ``` !> TSIZE is INTEGER !> The dimension of the array T. TSIZE >= 5. !> ``` *C* ``` !> C is 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. !> ``` *LDC* ``` !> LDC is INTEGER !> The leading dimension of the array C. LDC >= max(1,M). !> ``` *WORK* ``` !> (workspace) REAL array, dimension (MAX(1,LWORK)) !> ``` *LWORK* ``` !> LWORK is INTEGER !> The dimension of the array WORK. !> 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** ``` !> !> 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. !> This version of SGEMQR will use either SLAMTSQR or SGEMQRT to !> multiply matrix Q by another matrix. !> Further Details in SLAMTSQR or SGEMQRT. !> !> ``` Definition at line **172** of file **sgemqr.f**. ### subroutine zgemqr (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) **ZGEMQR** **Purpose:** ``` !> !> ZGEMQR overwrites the general real M-by-N matrix C with !> !> SIDE = 'L' SIDE = 'R' !> TRANS = 'N': Q * C C * Q !> TRANS = 'T': Q**H * C C * Q**H !> !> where Q is a complex unitary matrix defined as the product !> of blocked elementary reflectors computed by tall skinny !> QR factorization (ZGEQR) !> !> ``` **Parameters** *SIDE* ``` !> SIDE is CHARACTER*1 !> = 'L': apply Q or Q**H from the Left; !> = 'R': apply Q or Q**H from the Right. !> ``` *TRANS* ``` !> TRANS is CHARACTER*1 !> = 'N': No transpose, apply Q; !> = 'C': Conjugate transpose, apply Q**H. !> ``` *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 COMPLEX*16 array, dimension (LDA,K) !> Part of the data structure to represent Q as returned by ZGEQR. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. !> If SIDE = 'L', LDA >= max(1,M); !> if SIDE = 'R', LDA >= max(1,N). !> ``` *T* ``` !> T is COMPLEX*16 array, dimension (MAX(5,TSIZE)). !> Part of the data structure to represent Q as returned by ZGEQR. !> ``` *TSIZE* ``` !> TSIZE is INTEGER !> The dimension of the array T. TSIZE >= 5. !> ``` *C* ``` !> C is 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* ``` !> LDC is 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* ``` !> 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** ``` !> !> 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. !> This version of ZGEMQR will use either ZLAMTSQR or ZGEMQRT to !> multiply matrix Q by another matrix. !> Further Details in ZLAMTSQR or ZGEMQRT. !> !> ``` Definition at line **173** of file **zgemqr.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.