 LAPACK  3.10.0 LAPACK: Linear Algebra PACKage

## ◆ cgeqp3()

 subroutine cgeqp3 ( integer M, integer N, complex, dimension( lda, * ) A, integer LDA, integer, dimension( * ) JPVT, complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer LWORK, real, dimension( * ) RWORK, integer INFO )

CGEQP3

Purpose:
``` CGEQP3 computes a QR factorization with column pivoting of a
matrix A:  A*P = Q*R  using Level 3 BLAS.```
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 upper triangle of the array contains the min(M,N)-by-N upper trapezoidal matrix R; the elements below the diagonal, together with the array TAU, represent the unitary matrix Q as a product of min(M,N) elementary reflectors.``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).``` [in,out] JPVT ``` JPVT is INTEGER array, dimension (N) On entry, if JPVT(J).ne.0, the J-th column of A is permuted to the front of A*P (a leading column); if JPVT(J)=0, the J-th column of A is a free column. On exit, if JPVT(J)=K, then the J-th column of A*P was the the K-th column of A.``` [out] TAU ``` TAU is COMPLEX array, dimension (min(M,N)) The scalar factors of the elementary reflectors.``` [out] WORK ``` WORK is COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO=0, WORK(1) returns the optimal LWORK.``` [in] LWORK ``` LWORK is INTEGER The dimension of the array WORK. LWORK >= N+1. For optimal performance LWORK >= ( N+1 )*NB, where NB is the optimal blocksize. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.``` [out] RWORK ` RWORK is REAL array, dimension (2*N)` [out] INFO ``` INFO is INTEGER = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value.```
Further Details:
```  The matrix Q is represented as a product of elementary reflectors

Q = H(1) H(2) . . . H(k), where k = min(m,n).

Each H(i) has the form

H(i) = I - tau * v * v**H

where tau is a complex scalar, and v is a real/complex vector
with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in
A(i+1:m,i), and tau in TAU(i).```
Contributors:
G. Quintana-Orti, Depto. de Informatica, Universidad Jaime I, Spain X. Sun, Computer Science Dept., Duke University, USA

Definition at line 157 of file cgeqp3.f.

159 *
160 * -- LAPACK computational routine --
161 * -- LAPACK is a software package provided by Univ. of Tennessee, --
162 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
163 *
164 * .. Scalar Arguments ..
165  INTEGER INFO, LDA, LWORK, M, N
166 * ..
167 * .. Array Arguments ..
168  INTEGER JPVT( * )
169  REAL RWORK( * )
170  COMPLEX A( LDA, * ), TAU( * ), WORK( * )
171 * ..
172 *
173 * =====================================================================
174 *
175 * .. Parameters ..
176  INTEGER INB, INBMIN, IXOVER
177  parameter( inb = 1, inbmin = 2, ixover = 3 )
178 * ..
179 * .. Local Scalars ..
180  LOGICAL LQUERY
181  INTEGER FJB, IWS, J, JB, LWKOPT, MINMN, MINWS, NA, NB,
182  \$ NBMIN, NFXD, NX, SM, SMINMN, SN, TOPBMN
183 * ..
184 * .. External Subroutines ..
185  EXTERNAL cgeqrf, claqp2, claqps, cswap, cunmqr, xerbla
186 * ..
187 * .. External Functions ..
188  INTEGER ILAENV
189  REAL SCNRM2
190  EXTERNAL ilaenv, scnrm2
191 * ..
192 * .. Intrinsic Functions ..
193  INTRINSIC int, max, min
194 * ..
195 * .. Executable Statements ..
196 *
197 * Test input arguments
198 * ====================
199 *
200  info = 0
201  lquery = ( lwork.EQ.-1 )
202  IF( m.LT.0 ) THEN
203  info = -1
204  ELSE IF( n.LT.0 ) THEN
205  info = -2
206  ELSE IF( lda.LT.max( 1, m ) ) THEN
207  info = -4
208  END IF
209 *
210  IF( info.EQ.0 ) THEN
211  minmn = min( m, n )
212  IF( minmn.EQ.0 ) THEN
213  iws = 1
214  lwkopt = 1
215  ELSE
216  iws = n + 1
217  nb = ilaenv( inb, 'CGEQRF', ' ', m, n, -1, -1 )
218  lwkopt = ( n + 1 )*nb
219  END IF
220  work( 1 ) = cmplx( lwkopt )
221 *
222  IF( ( lwork.LT.iws ) .AND. .NOT.lquery ) THEN
223  info = -8
224  END IF
225  END IF
226 *
227  IF( info.NE.0 ) THEN
228  CALL xerbla( 'CGEQP3', -info )
229  RETURN
230  ELSE IF( lquery ) THEN
231  RETURN
232  END IF
233 *
234 * Move initial columns up front.
235 *
236  nfxd = 1
237  DO 10 j = 1, n
238  IF( jpvt( j ).NE.0 ) THEN
239  IF( j.NE.nfxd ) THEN
240  CALL cswap( m, a( 1, j ), 1, a( 1, nfxd ), 1 )
241  jpvt( j ) = jpvt( nfxd )
242  jpvt( nfxd ) = j
243  ELSE
244  jpvt( j ) = j
245  END IF
246  nfxd = nfxd + 1
247  ELSE
248  jpvt( j ) = j
249  END IF
250  10 CONTINUE
251  nfxd = nfxd - 1
252 *
253 * Factorize fixed columns
254 * =======================
255 *
256 * Compute the QR factorization of fixed columns and update
257 * remaining columns.
258 *
259  IF( nfxd.GT.0 ) THEN
260  na = min( m, nfxd )
261 *CC CALL CGEQR2( M, NA, A, LDA, TAU, WORK, INFO )
262  CALL cgeqrf( m, na, a, lda, tau, work, lwork, info )
263  iws = max( iws, int( work( 1 ) ) )
264  IF( na.LT.n ) THEN
265 *CC CALL CUNM2R( 'Left', 'Conjugate Transpose', M, N-NA,
266 *CC \$ NA, A, LDA, TAU, A( 1, NA+1 ), LDA, WORK,
267 *CC \$ INFO )
268  CALL cunmqr( 'Left', 'Conjugate Transpose', m, n-na, na, a,
269  \$ lda, tau, a( 1, na+1 ), lda, work, lwork,
270  \$ info )
271  iws = max( iws, int( work( 1 ) ) )
272  END IF
273  END IF
274 *
275 * Factorize free columns
276 * ======================
277 *
278  IF( nfxd.LT.minmn ) THEN
279 *
280  sm = m - nfxd
281  sn = n - nfxd
282  sminmn = minmn - nfxd
283 *
284 * Determine the block size.
285 *
286  nb = ilaenv( inb, 'CGEQRF', ' ', sm, sn, -1, -1 )
287  nbmin = 2
288  nx = 0
289 *
290  IF( ( nb.GT.1 ) .AND. ( nb.LT.sminmn ) ) THEN
291 *
292 * Determine when to cross over from blocked to unblocked code.
293 *
294  nx = max( 0, ilaenv( ixover, 'CGEQRF', ' ', sm, sn, -1,
295  \$ -1 ) )
296 *
297 *
298  IF( nx.LT.sminmn ) THEN
299 *
300 * Determine if workspace is large enough for blocked code.
301 *
302  minws = ( sn+1 )*nb
303  iws = max( iws, minws )
304  IF( lwork.LT.minws ) THEN
305 *
306 * Not enough workspace to use optimal NB: Reduce NB and
307 * determine the minimum value of NB.
308 *
309  nb = lwork / ( sn+1 )
310  nbmin = max( 2, ilaenv( inbmin, 'CGEQRF', ' ', sm, sn,
311  \$ -1, -1 ) )
312 *
313 *
314  END IF
315  END IF
316  END IF
317 *
318 * Initialize partial column norms. The first N elements of work
319 * store the exact column norms.
320 *
321  DO 20 j = nfxd + 1, n
322  rwork( j ) = scnrm2( sm, a( nfxd+1, j ), 1 )
323  rwork( n+j ) = rwork( j )
324  20 CONTINUE
325 *
326  IF( ( nb.GE.nbmin ) .AND. ( nb.LT.sminmn ) .AND.
327  \$ ( nx.LT.sminmn ) ) THEN
328 *
329 * Use blocked code initially.
330 *
331  j = nfxd + 1
332 *
333 * Compute factorization: while loop.
334 *
335 *
336  topbmn = minmn - nx
337  30 CONTINUE
338  IF( j.LE.topbmn ) THEN
339  jb = min( nb, topbmn-j+1 )
340 *
341 * Factorize JB columns among columns J:N.
342 *
343  CALL claqps( m, n-j+1, j-1, jb, fjb, a( 1, j ), lda,
344  \$ jpvt( j ), tau( j ), rwork( j ),
345  \$ rwork( n+j ), work( 1 ), work( jb+1 ),
346  \$ n-j+1 )
347 *
348  j = j + fjb
349  GO TO 30
350  END IF
351  ELSE
352  j = nfxd + 1
353  END IF
354 *
355 * Use unblocked code to factor the last or only block.
356 *
357 *
358  IF( j.LE.minmn )
359  \$ CALL claqp2( m, n-j+1, j-1, a( 1, j ), lda, jpvt( j ),
360  \$ tau( j ), rwork( j ), rwork( n+j ), work( 1 ) )
361 *
362  END IF
363 *
364  work( 1 ) = cmplx( lwkopt )
365  RETURN
366 *
367 * End of CGEQP3
368 *
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: ilaenv.f:162
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
subroutine cswap(N, CX, INCX, CY, INCY)
CSWAP
Definition: cswap.f:81
subroutine cgeqrf(M, N, A, LDA, TAU, WORK, LWORK, INFO)
CGEQRF
Definition: cgeqrf.f:145
subroutine claqp2(M, N, OFFSET, A, LDA, JPVT, TAU, VN1, VN2, WORK)
CLAQP2 computes a QR factorization with column pivoting of the matrix block.
Definition: claqp2.f:149
subroutine claqps(M, N, OFFSET, NB, KB, A, LDA, JPVT, TAU, VN1, VN2, AUXV, F, LDF)
CLAQPS computes a step of QR factorization with column pivoting of a real m-by-n matrix A by using BL...
Definition: claqps.f:178
subroutine cunmqr(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
CUNMQR
Definition: cunmqr.f:168
real(wp) function scnrm2(n, x, incx)
SCNRM2
Definition: scnrm2.f90:90
Here is the call graph for this function:
Here is the caller graph for this function: