LAPACK  3.10.1
LAPACK: Linear Algebra PACKage

◆ cgerqf()

subroutine cgerqf ( integer  M,
integer  N,
complex, dimension( lda, * )  A,
integer  LDA,
complex, dimension( * )  TAU,
complex, dimension( * )  WORK,
integer  LWORK,
integer  INFO 
)

CGERQF

Download CGERQF + dependencies [TGZ] [ZIP] [TXT]

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
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
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  EXTERNAL ilaenv
167 * ..
168 * .. Executable Statements ..
169 *
170 * Test the input arguments
171 *
172  info = 0
173  lquery = ( lwork.EQ.-1 )
174  IF( m.LT.0 ) THEN
175  info = -1
176  ELSE IF( n.LT.0 ) THEN
177  info = -2
178  ELSE IF( lda.LT.max( 1, m ) ) THEN
179  info = -4
180  END IF
181 *
182  IF( info.EQ.0 ) THEN
183  k = min( m, n )
184  IF( k.EQ.0 ) THEN
185  lwkopt = 1
186  ELSE
187  nb = ilaenv( 1, 'CGERQF', ' ', m, n, -1, -1 )
188  lwkopt = m*nb
189  END IF
190  work( 1 ) = lwkopt
191 *
192  IF ( .NOT.lquery ) THEN
193  IF( lwork.LE.0 .OR. ( n.GT.0 .AND. lwork.LT.max( 1, m ) ) )
194  $ info = -7
195  END IF
196  END IF
197 *
198  IF( info.NE.0 ) THEN
199  CALL xerbla( 'CGERQF', -info )
200  RETURN
201  ELSE IF( lquery ) THEN
202  RETURN
203  END IF
204 *
205 * Quick return if possible
206 *
207  IF( k.EQ.0 ) THEN
208  RETURN
209  END IF
210 *
211  nbmin = 2
212  nx = 1
213  iws = m
214  IF( nb.GT.1 .AND. nb.LT.k ) THEN
215 *
216 * Determine when to cross over from blocked to unblocked code.
217 *
218  nx = max( 0, ilaenv( 3, 'CGERQF', ' ', m, n, -1, -1 ) )
219  IF( nx.LT.k ) THEN
220 *
221 * Determine if workspace is large enough for blocked code.
222 *
223  ldwork = m
224  iws = ldwork*nb
225  IF( lwork.LT.iws ) THEN
226 *
227 * Not enough workspace to use optimal NB: reduce NB and
228 * determine the minimum value of NB.
229 *
230  nb = lwork / ldwork
231  nbmin = max( 2, ilaenv( 2, 'CGERQF', ' ', m, n, -1,
232  $ -1 ) )
233  END IF
234  END IF
235  END IF
236 *
237  IF( nb.GE.nbmin .AND. nb.LT.k .AND. nx.LT.k ) THEN
238 *
239 * Use blocked code initially.
240 * The last kk rows are handled by the block method.
241 *
242  ki = ( ( k-nx-1 ) / nb )*nb
243  kk = min( k, ki+nb )
244 *
245  DO 10 i = k - kk + ki + 1, k - kk + 1, -nb
246  ib = min( k-i+1, nb )
247 *
248 * Compute the RQ factorization of the current block
249 * A(m-k+i:m-k+i+ib-1,1:n-k+i+ib-1)
250 *
251  CALL cgerq2( ib, n-k+i+ib-1, a( m-k+i, 1 ), lda, tau( i ),
252  $ work, iinfo )
253  IF( m-k+i.GT.1 ) THEN
254 *
255 * Form the triangular factor of the block reflector
256 * H = H(i+ib-1) . . . H(i+1) H(i)
257 *
258  CALL clarft( 'Backward', 'Rowwise', n-k+i+ib-1, ib,
259  $ a( m-k+i, 1 ), lda, tau( i ), work, ldwork )
260 *
261 * Apply H to A(1:m-k+i-1,1:n-k+i+ib-1) from the right
262 *
263  CALL clarfb( 'Right', 'No transpose', 'Backward',
264  $ 'Rowwise', m-k+i-1, n-k+i+ib-1, ib,
265  $ a( m-k+i, 1 ), lda, work, ldwork, a, lda,
266  $ work( ib+1 ), ldwork )
267  END IF
268  10 CONTINUE
269  mu = m - k + i + nb - 1
270  nu = n - k + i + nb - 1
271  ELSE
272  mu = m
273  nu = n
274  END IF
275 *
276 * Use unblocked code to factor the last or only block
277 *
278  IF( mu.GT.0 .AND. nu.GT.0 )
279  $ CALL cgerq2( mu, nu, a, lda, tau, work, iinfo )
280 *
281  work( 1 ) = iws
282  RETURN
283 *
284 * End of CGERQF
285 *
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 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
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
Here is the call graph for this function:
Here is the caller graph for this function: