--- name: "gelqt" 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/gelqt" --- # gelqt(3) gelqt: LQ factor, with T ## NAME gelqt - gelqt: LQ factor, with T ## SYNOPSIS ### Functions subroutine **cgelqt** (m, n, mb, a, lda, t, ldt, work, info)\ **CGELQT** subroutine **dgelqt** (m, n, mb, a, lda, t, ldt, work, info)\ **DGELQT** subroutine **sgelqt** (m, n, mb, a, lda, t, ldt, work, info)\ **SGELQT** subroutine **zgelqt** (m, n, mb, a, lda, t, ldt, work, info)\ **ZGELQT** ## Detailed Description ## Function Documentation ### subroutine cgelqt (integer m, integer n, integer mb, complex, dimension( lda, \* ) a, integer lda, complex, dimension( ldt, \* ) t, integer ldt, complex, dimension( \* ) work, integer info) **CGELQT** **Purpose:** ``` !> !> CGELQT computes a blocked LQ factorization of a complex M-by-N matrix A !> using the compact WY representation of Q. !> ``` **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. !> ``` *MB* ``` !> MB is INTEGER !> The block size to be used in the blocked QR. MIN(M,N) >= MB >= 1. !> ``` *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 the rows of V. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *T* ``` !> T is COMPLEX array, dimension (LDT,MIN(M,N)) !> The upper triangular block reflectors stored in compact form !> as a sequence of upper triangular blocks. See below !> for further details. !> ``` *LDT* ``` !> LDT is INTEGER !> The leading dimension of the array T. LDT >= MB. !> ``` *WORK* ``` !> WORK is COMPLEX array, dimension (MB*N) !> ``` *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 matrix V stores the elementary reflectors H(i) in the i-th row !> above the diagonal. For example, if M=5 and N=3, the matrix V is !> !> V = ( 1 v1 v1 v1 v1 ) !> ( 1 v2 v2 v2 ) !> ( 1 v3 v3 ) !> !> !> where the vi's represent the vectors which define H(i), which are returned !> in the matrix A. The 1's along the diagonal of V are not stored in A. !> Let K=MIN(M,N). The number of blocks is B = ceiling(K/MB), where each !> block is of order MB except for the last block, which is of order !> IB = K - (B-1)*MB. For each of the B blocks, a upper triangular block !> reflector factor is computed: T1, T2, ..., TB. The MB-by-MB (and IB-by-IB !> for the last block) T's are stored in the MB-by-K matrix T as !> !> T = (T1 T2 ... TB). !> ``` Definition at line **123** of file **cgelqt.f**. ### subroutine dgelqt (integer m, integer n, integer mb, double precision, dimension( lda, \* ) a, integer lda, double precision, dimension( ldt, \* ) t, integer ldt, double precision, dimension( \* ) work, integer info) **DGELQT** **Purpose:** ``` !> !> DGELQT computes a blocked LQ factorization of a real M-by-N matrix A !> using the compact WY representation of Q. !> ``` **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. !> ``` *MB* ``` !> MB is INTEGER !> The block size to be used in the blocked QR. MIN(M,N) >= MB >= 1. !> ``` *A* ``` !> A is DOUBLE PRECISION 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 the rows of V. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *T* ``` !> T is DOUBLE PRECISION array, dimension (LDT,MIN(M,N)) !> The upper triangular block reflectors stored in compact form !> as a sequence of upper triangular blocks. See below !> for further details. !> ``` *LDT* ``` !> LDT is INTEGER !> The leading dimension of the array T. LDT >= MB. !> ``` *WORK* ``` !> WORK is DOUBLE PRECISION array, dimension (MB*N) !> ``` *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 matrix V stores the elementary reflectors H(i) in the i-th row !> above the diagonal. For example, if M=5 and N=3, the matrix V is !> !> V = ( 1 v1 v1 v1 v1 ) !> ( 1 v2 v2 v2 ) !> ( 1 v3 v3 ) !> !> !> where the vi's represent the vectors which define H(i), which are returned !> in the matrix A. The 1's along the diagonal of V are not stored in A. !> Let K=MIN(M,N). The number of blocks is B = ceiling(K/MB), where each !> block is of order MB except for the last block, which is of order !> IB = K - (B-1)*MB. For each of the B blocks, a upper triangular block !> reflector factor is computed: T1, T2, ..., TB. The MB-by-MB (and IB-by-IB !> for the last block) T's are stored in the MB-by-K matrix T as !> !> T = (T1 T2 ... TB). !> ``` Definition at line **138** of file **dgelqt.f**. ### subroutine sgelqt (integer m, integer n, integer mb, real, dimension( lda, \* ) a, integer lda, real, dimension( ldt, \* ) t, integer ldt, real, dimension( \* ) work, integer info) **SGELQT** **Purpose:** ``` !> !> SGELQT computes a blocked LQ factorization of a real M-by-N matrix A !> using the compact WY representation of Q. !> ``` **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. !> ``` *MB* ``` !> MB is INTEGER !> The block size to be used in the blocked QR. MIN(M,N) >= MB >= 1. !> ``` *A* ``` !> A is REAL 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 the rows of V. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *T* ``` !> T is REAL array, dimension (LDT,MIN(M,N)) !> The upper triangular block reflectors stored in compact form !> as a sequence of upper triangular blocks. See below !> for further details. !> ``` *LDT* ``` !> LDT is INTEGER !> The leading dimension of the array T. LDT >= MB. !> ``` *WORK* ``` !> WORK is REAL array, dimension (MB*N) !> ``` *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 matrix V stores the elementary reflectors H(i) in the i-th row !> above the diagonal. For example, if M=5 and N=3, the matrix V is !> !> V = ( 1 v1 v1 v1 v1 ) !> ( 1 v2 v2 v2 ) !> ( 1 v3 v3 ) !> !> !> where the vi's represent the vectors which define H(i), which are returned !> in the matrix A. The 1's along the diagonal of V are not stored in A. !> Let K=MIN(M,N). The number of blocks is B = ceiling(K/MB), where each !> block is of order MB except for the last block, which is of order !> IB = K - (B-1)*MB. For each of the B blocks, a upper triangular block !> reflector factor is computed: T1, T2, ..., TB. The MB-by-MB (and IB-by-IB !> for the last block) T's are stored in the MB-by-K matrix T as !> !> T = (T1 T2 ... TB). !> ``` Definition at line **123** of file **sgelqt.f**. ### subroutine zgelqt (integer m, integer n, integer mb, complex\*16, dimension( lda, \* ) a, integer lda, complex\*16, dimension( ldt, \* ) t, integer ldt, complex\*16, dimension( \* ) work, integer info) **ZGELQT** **Purpose:** ``` !> !> ZGELQT computes a blocked LQ factorization of a complex M-by-N matrix A !> using the compact WY representation of Q. !> ``` **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. !> ``` *MB* ``` !> MB is INTEGER !> The block size to be used in the blocked QR. MIN(M,N) >= MB >= 1. !> ``` *A* ``` !> A is COMPLEX*16 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 the rows of V. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !> ``` *T* ``` !> T is COMPLEX*16 array, dimension (LDT,MIN(M,N)) !> The upper triangular block reflectors stored in compact form !> as a sequence of upper triangular blocks. See below !> for further details. !> ``` *LDT* ``` !> LDT is INTEGER !> The leading dimension of the array T. LDT >= MB. !> ``` *WORK* ``` !> WORK is COMPLEX*16 array, dimension (MB*N) !> ``` *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 matrix V stores the elementary reflectors H(i) in the i-th row !> above the diagonal. For example, if M=5 and N=3, the matrix V is !> !> V = ( 1 v1 v1 v1 v1 ) !> ( 1 v2 v2 v2 ) !> ( 1 v3 v3 ) !> !> !> where the vi's represent the vectors which define H(i), which are returned !> in the matrix A. The 1's along the diagonal of V are not stored in A. !> Let K=MIN(M,N). The number of blocks is B = ceiling(K/MB), where each !> block is of order MB except for the last block, which is of order !> IB = K - (B-1)*MB. For each of the B blocks, a upper triangular block !> reflector factor is computed: T1, T2, ..., TB. The MB-by-MB (and IB-by-IB !> for the last block) T's are stored in the MB-by-K matrix T as !> !> T = (T1 T2 ... TB). !> ``` Definition at line **138** of file **zgelqt.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.