LAPACK  3.8.0 LAPACK: Linear Algebra PACKage

## ◆ zgelq()

 subroutine zgelq ( 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 )
Purpose:
ZGELQ computes a LQ factorization of an M-by-N matrix A.
Parameters
 [in] M ``` M is INTEGER The number of rows of the matrix A. M >= 0.``` [in] N ``` N is INTEGER The number of columns of the matrix A. N >= 0.``` [in,out] 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 used to store part of the data structure to represent Q.``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).``` [out] 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.``` [in] 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).``` [out] 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.``` [in] 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 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).``` [out] INFO ``` INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value```
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 unlikely not 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 ZLASWLQ or ZGELQT

Depending on the matrix dimensions M and N, and row and column block sizes MB and NB returned by ILAENV, ZGELQ will use either ZLASWLQ (if the matrix is short-and-wide) or ZGELQT to compute the LQ factorization.

Definition at line 161 of file zgelq.f.

161 *
162 * -- LAPACK computational routine (version 3.7.0) --
163 * -- LAPACK is a software package provided by Univ. of Tennessee, --
164 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd. --
165 * December 2016
166 *
167 * .. Scalar Arguments ..
168  INTEGER info, lda, m, n, tsize, lwork
169 * ..
170 * .. Array Arguments ..
171  COMPLEX*16 a( lda, * ), t( * ), work( * )
172 * ..
173 *
174 * =====================================================================
175 *
176 * ..
177 * .. Local Scalars ..
178  LOGICAL lquery, lminws, mint, minw
179  INTEGER mb, nb, mintsz, nblcks
180 * ..
181 * .. External Functions ..
182  LOGICAL lsame
183  EXTERNAL lsame
184 * ..
185 * .. External Subroutines ..
186  EXTERNAL zgelqt, zlaswlq, xerbla
187 * ..
188 * .. Intrinsic Functions ..
189  INTRINSIC max, min, mod
190 * ..
191 * .. External Functions ..
192  INTEGER ilaenv
193  EXTERNAL ilaenv
194 * ..
195 * .. Executable Statements ..
196 *
197 * Test the input arguments
198 *
199  info = 0
200 *
201  lquery = ( tsize.EQ.-1 .OR. tsize.EQ.-2 .OR.
202  \$ lwork.EQ.-1 .OR. lwork.EQ.-2 )
203 *
204  mint = .false.
205  minw = .false.
206  IF( tsize.EQ.-2 .OR. lwork.EQ.-2 ) THEN
207  IF( tsize.NE.-1 ) mint = .true.
208  IF( lwork.NE.-1 ) minw = .true.
209  END IF
210 *
211 * Determine the block size
212 *
213  IF( min( m, n ).GT.0 ) THEN
214  mb = ilaenv( 1, 'ZGELQ ', ' ', m, n, 1, -1 )
215  nb = ilaenv( 1, 'ZGELQ ', ' ', m, n, 2, -1 )
216  ELSE
217  mb = 1
218  nb = n
219  END IF
220  IF( mb.GT.min( m, n ) .OR. mb.LT.1 ) mb = 1
221  IF( nb.GT.n .OR. nb.LE.m ) nb = n
222  mintsz = m + 5
223  IF ( nb.GT.m .AND. n.GT.m ) THEN
224  IF( mod( n - m, nb - m ).EQ.0 ) THEN
225  nblcks = ( n - m ) / ( nb - m )
226  ELSE
227  nblcks = ( n - m ) / ( nb - m ) + 1
228  END IF
229  ELSE
230  nblcks = 1
231  END IF
232 *
233 * Determine if the workspace size satisfies minimal size
234 *
235  lminws = .false.
236  IF( ( tsize.LT.max( 1, mb*m*nblcks + 5 ) .OR. lwork.LT.mb*m )
237  \$ .AND. ( lwork.GE.m ) .AND. ( tsize.GE.mintsz )
238  \$ .AND. ( .NOT.lquery ) ) THEN
239  IF( tsize.LT.max( 1, mb*m*nblcks + 5 ) ) THEN
240  lminws = .true.
241  mb = 1
242  nb = n
243  END IF
244  IF( lwork.LT.mb*m ) THEN
245  lminws = .true.
246  mb = 1
247  END IF
248  END IF
249 *
250  IF( m.LT.0 ) THEN
251  info = -1
252  ELSE IF( n.LT.0 ) THEN
253  info = -2
254  ELSE IF( lda.LT.max( 1, m ) ) THEN
255  info = -4
256  ELSE IF( tsize.LT.max( 1, mb*m*nblcks + 5 )
257  \$ .AND. ( .NOT.lquery ) .AND. ( .NOT.lminws ) ) THEN
258  info = -6
259  ELSE IF( ( lwork.LT.max( 1, m*mb ) ) .and .( .NOT.lquery )
260  \$ .AND. ( .NOT.lminws ) ) THEN
261  info = -8
262  END IF
263 *
264  IF( info.EQ.0 ) THEN
265  IF( mint ) THEN
266  t( 1 ) = mintsz
267  ELSE
268  t( 1 ) = mb*m*nblcks + 5
269  END IF
270  t( 2 ) = mb
271  t( 3 ) = nb
272  IF( minw ) THEN
273  work( 1 ) = max( 1, n )
274  ELSE
275  work( 1 ) = max( 1, mb*m )
276  END IF
277  END IF
278  IF( info.NE.0 ) THEN
279  CALL xerbla( 'ZGELQ', -info )
280  RETURN
281  ELSE IF( lquery ) THEN
282  RETURN
283  END IF
284 *
285 * Quick return if possible
286 *
287  IF( min( m, n ).EQ.0 ) THEN
288  RETURN
289  END IF
290 *
291 * The LQ Decomposition
292 *
293  IF( ( n.LE.m ) .OR. ( nb.LE.m ) .OR. ( nb.GE.n ) ) THEN
294  CALL zgelqt( m, n, mb, a, lda, t( 6 ), mb, work, info )
295  ELSE
296  CALL zlaswlq( m, n, mb, nb, a, lda, t( 6 ), mb, work,
297  \$ lwork, info )
298  END IF
299 *
300  work( 1 ) = max( 1, mb*m )
301 *
302  RETURN
303 *
304 * End of ZGELQ
305 *
subroutine zgelqt(M, N, MB, A, LDA, T, LDT, WORK, INFO)
ZGELQT
Definition: zgelqt.f:141
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: tstiee.f:83
subroutine zlaswlq(M, N, MB, NB, A, LDA, T, LDT, WORK, LWORK, INFO)
Definition: zlaswlq.f:152
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
Here is the call graph for this function:
Here is the caller graph for this function: