LAPACK  3.10.1 LAPACK: Linear Algebra PACKage

## ◆ sgerqf()

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

SGERQF

Purpose:
``` SGERQF computes an RQ factorization of a real 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 REAL 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 orthogonal 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 REAL array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Details).``` [out] WORK ``` WORK is REAL 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(2) . . . H(k), where k = min(m,n).

Each H(i) has the form

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

where tau is a real scalar, and v is a real vector with
v(n-k+i+1:n) = 0 and v(n-k+i) = 1; 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 sgerqf.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  REAL 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 sgerq2, slarfb, slarft, 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, 'SGERQF', ' ', 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( 'SGERQF', -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, 'SGERQF', ' ', 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, 'SGERQF', ' ', 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 sgerq2( 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 slarft( '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 slarfb( '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 sgerq2( mu, nu, a, lda, tau, work, iinfo )
280 *
281  work( 1 ) = iws
282  RETURN
283 *
284 * End of SGERQF
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 sgerq2(M, N, A, LDA, TAU, WORK, INFO)
SGERQ2 computes the RQ factorization of a general rectangular matrix using an unblocked algorithm.
Definition: sgerq2.f:123
subroutine slarfb(SIDE, TRANS, DIRECT, STOREV, M, N, K, V, LDV, T, LDT, C, LDC, WORK, LDWORK)
SLARFB applies a block reflector or its transpose to a general rectangular matrix.
Definition: slarfb.f:197
subroutine slarft(DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT)
SLARFT forms the triangular factor T of a block reflector H = I - vtvH
Definition: slarft.f:163
Here is the call graph for this function:
Here is the caller graph for this function: