 LAPACK  3.10.1 LAPACK: Linear Algebra PACKage

## ◆ cgeqr()

 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
 [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 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 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 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
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 172 of file cgeqr.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 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 clatsqr, cgeqrt, 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, 'CGEQR ', ' ', m, n, 1, -1 )
227  nb = ilaenv( 1, 'CGEQR ', ' ', 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( 'CGEQR', -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 cgeqrt( m, n, nb, a, lda, t( 6 ), nb, work, info )
307  ELSE
308  CALL clatsqr( 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 CGEQR
317 *
subroutine clatsqr(M, N, MB, NB, A, LDA, T, LDT, WORK, LWORK, INFO)
CLATSQR
Definition: clatsqr.f:166
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 cgeqrt(M, N, NB, A, LDA, T, LDT, WORK, INFO)
CGEQRT
Definition: cgeqrt.f:141
Here is the call graph for this function:
Here is the caller graph for this function: