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

## ◆ cgerqf()

 subroutine cgerqf ( integer m, integer n, complex, dimension( lda, * ) a, integer lda, complex, dimension( * ) tau, complex, dimension( * ) work, integer lwork, integer info )

CGERQF

Purpose:
``` CGERQF computes an RQ factorization of a complex M-by-N matrix A:
A = R * Q.```
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, if m <= n, the upper triangle of the subarray A(1:m,n-m+1:n) contains the M-by-M upper triangular matrix R; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the M-by-N upper trapezoidal matrix R; the remaining elements, with the array TAU, represent the unitary matrix Q as a product of min(m,n) elementary reflectors (see Further Details).``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).``` [out] TAU ``` TAU is COMPLEX array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Details).``` [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 >= 1, if MIN(M,N) = 0, and LWORK >= M, otherwise. For optimum performance LWORK >= M*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] 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 H(2)**H . . . H(k)**H, 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 complex vector with
v(n-k+i+1:n) = 0 and v(n-k+i) = 1; conjg(v(1:n-k+i-1)) is stored on
exit in A(m-k+i,1:n-k+i-1), and tau in TAU(i).```

Definition at line 138 of file cgerqf.f.

139*
140* -- LAPACK computational routine --
141* -- LAPACK is a software package provided by Univ. of Tennessee, --
142* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
143*
144* .. Scalar Arguments ..
145 INTEGER INFO, LDA, LWORK, M, N
146* ..
147* .. Array Arguments ..
148 COMPLEX A( LDA, * ), TAU( * ), WORK( * )
149* ..
150*
151* =====================================================================
152*
153* .. Local Scalars ..
154 LOGICAL LQUERY
155 INTEGER I, IB, IINFO, IWS, K, KI, KK, LDWORK, LWKOPT,
156 \$ MU, NB, NBMIN, NU, NX
157* ..
158* .. External Subroutines ..
159 EXTERNAL cgerq2, clarfb, clarft, xerbla
160* ..
161* .. Intrinsic Functions ..
162 INTRINSIC max, min
163* ..
164* .. External Functions ..
165 INTEGER ILAENV
166 REAL SROUNDUP_LWORK
167 EXTERNAL ilaenv, sroundup_lwork
168* ..
169* .. Executable Statements ..
170*
171* Test the input arguments
172*
173 info = 0
174 lquery = ( lwork.EQ.-1 )
175 IF( m.LT.0 ) THEN
176 info = -1
177 ELSE IF( n.LT.0 ) THEN
178 info = -2
179 ELSE IF( lda.LT.max( 1, m ) ) THEN
180 info = -4
181 END IF
182*
183 IF( info.EQ.0 ) THEN
184 k = min( m, n )
185 IF( k.EQ.0 ) THEN
186 lwkopt = 1
187 ELSE
188 nb = ilaenv( 1, 'CGERQF', ' ', m, n, -1, -1 )
189 lwkopt = m*nb
190 END IF
191 work( 1 ) = sroundup_lwork(lwkopt)
192*
193 IF ( .NOT.lquery ) THEN
194 IF( lwork.LE.0 .OR. ( n.GT.0 .AND. lwork.LT.max( 1, m ) ) )
195 \$ info = -7
196 END IF
197 END IF
198*
199 IF( info.NE.0 ) THEN
200 CALL xerbla( 'CGERQF', -info )
201 RETURN
202 ELSE IF( lquery ) THEN
203 RETURN
204 END IF
205*
206* Quick return if possible
207*
208 IF( k.EQ.0 ) THEN
209 RETURN
210 END IF
211*
212 nbmin = 2
213 nx = 1
214 iws = m
215 IF( nb.GT.1 .AND. nb.LT.k ) THEN
216*
217* Determine when to cross over from blocked to unblocked code.
218*
219 nx = max( 0, ilaenv( 3, 'CGERQF', ' ', m, n, -1, -1 ) )
220 IF( nx.LT.k ) THEN
221*
222* Determine if workspace is large enough for blocked code.
223*
224 ldwork = m
225 iws = ldwork*nb
226 IF( lwork.LT.iws ) THEN
227*
228* Not enough workspace to use optimal NB: reduce NB and
229* determine the minimum value of NB.
230*
231 nb = lwork / ldwork
232 nbmin = max( 2, ilaenv( 2, 'CGERQF', ' ', m, n, -1,
233 \$ -1 ) )
234 END IF
235 END IF
236 END IF
237*
238 IF( nb.GE.nbmin .AND. nb.LT.k .AND. nx.LT.k ) THEN
239*
240* Use blocked code initially.
241* The last kk rows are handled by the block method.
242*
243 ki = ( ( k-nx-1 ) / nb )*nb
244 kk = min( k, ki+nb )
245*
246 DO 10 i = k - kk + ki + 1, k - kk + 1, -nb
247 ib = min( k-i+1, nb )
248*
249* Compute the RQ factorization of the current block
250* A(m-k+i:m-k+i+ib-1,1:n-k+i+ib-1)
251*
252 CALL cgerq2( ib, n-k+i+ib-1, a( m-k+i, 1 ), lda, tau( i ),
253 \$ work, iinfo )
254 IF( m-k+i.GT.1 ) THEN
255*
256* Form the triangular factor of the block reflector
257* H = H(i+ib-1) . . . H(i+1) H(i)
258*
259 CALL clarft( 'Backward', 'Rowwise', n-k+i+ib-1, ib,
260 \$ a( m-k+i, 1 ), lda, tau( i ), work, ldwork )
261*
262* Apply H to A(1:m-k+i-1,1:n-k+i+ib-1) from the right
263*
264 CALL clarfb( 'Right', 'No transpose', 'Backward',
265 \$ 'Rowwise', m-k+i-1, n-k+i+ib-1, ib,
266 \$ a( m-k+i, 1 ), lda, work, ldwork, a, lda,
267 \$ work( ib+1 ), ldwork )
268 END IF
269 10 CONTINUE
270 mu = m - k + i + nb - 1
271 nu = n - k + i + nb - 1
272 ELSE
273 mu = m
274 nu = n
275 END IF
276*
277* Use unblocked code to factor the last or only block
278*
279 IF( mu.GT.0 .AND. nu.GT.0 )
280 \$ CALL cgerq2( mu, nu, a, lda, tau, work, iinfo )
281*
282 work( 1 ) = sroundup_lwork(iws)
283 RETURN
284*
285* End of CGERQF
286*
subroutine xerbla(srname, info)
Definition cblat2.f:3285
subroutine cgerq2(m, n, a, lda, tau, work, info)
CGERQ2 computes the RQ factorization of a general rectangular matrix using an unblocked algorithm.
Definition cgerq2.f:123
integer function ilaenv(ispec, name, opts, n1, n2, n3, n4)
ILAENV
Definition ilaenv.f:162
subroutine clarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork)
CLARFB applies a block reflector or its conjugate-transpose to a general rectangular matrix.
Definition clarfb.f:197
subroutine clarft(direct, storev, n, k, v, ldv, tau, t, ldt)
CLARFT forms the triangular factor T of a block reflector H = I - vtvH
Definition clarft.f:163
real function sroundup_lwork(lwork)
SROUNDUP_LWORK
Here is the call graph for this function:
Here is the caller graph for this function: