 LAPACK 3.11.0 LAPACK: Linear Algebra PACKage
Searching...
No Matches

## ◆ zgeqr()

 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
 [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 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.``` [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 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 172 of file zgeqr.f.

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