 LAPACK  3.10.1 LAPACK: Linear Algebra PACKage

## ◆ sorgqr()

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

SORGQR

Purpose:
``` SORGQR generates an M-by-N real matrix Q with orthonormal columns,
which is defined as the first N columns of a product of K elementary
reflectors of order M

Q  =  H(1) H(2) . . . H(k)

as returned by SGEQRF.```
Parameters
 [in] M ``` M is INTEGER The number of rows of the matrix Q. M >= 0.``` [in] N ``` N is INTEGER The number of columns of the matrix Q. M >= N >= 0.``` [in] K ``` K is INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.``` [in,out] A ``` A is REAL array, dimension (LDA,N) On entry, the i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by SGEQRF in the first k columns of its array argument A. On exit, the M-by-N matrix Q.``` [in] LDA ``` LDA is INTEGER The first dimension of the array A. LDA >= max(1,M).``` [in] TAU ``` TAU is REAL array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQRF.``` [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 >= max(1,N). For optimum performance LWORK >= N*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 has an illegal value```

Definition at line 127 of file sorgqr.f.

128 *
129 * -- LAPACK computational routine --
130 * -- LAPACK is a software package provided by Univ. of Tennessee, --
131 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
132 *
133 * .. Scalar Arguments ..
134  INTEGER INFO, K, LDA, LWORK, M, N
135 * ..
136 * .. Array Arguments ..
137  REAL A( LDA, * ), TAU( * ), WORK( * )
138 * ..
139 *
140 * =====================================================================
141 *
142 * .. Parameters ..
143  REAL ZERO
144  parameter( zero = 0.0e+0 )
145 * ..
146 * .. Local Scalars ..
147  LOGICAL LQUERY
148  INTEGER I, IB, IINFO, IWS, J, KI, KK, L, LDWORK,
149  \$ LWKOPT, NB, NBMIN, NX
150 * ..
151 * .. External Subroutines ..
152  EXTERNAL slarfb, slarft, sorg2r, xerbla
153 * ..
154 * .. Intrinsic Functions ..
155  INTRINSIC max, min
156 * ..
157 * .. External Functions ..
158  INTEGER ILAENV
159  EXTERNAL ilaenv
160 * ..
161 * .. Executable Statements ..
162 *
163 * Test the input arguments
164 *
165  info = 0
166  nb = ilaenv( 1, 'SORGQR', ' ', m, n, k, -1 )
167  lwkopt = max( 1, n )*nb
168  work( 1 ) = lwkopt
169  lquery = ( lwork.EQ.-1 )
170  IF( m.LT.0 ) THEN
171  info = -1
172  ELSE IF( n.LT.0 .OR. n.GT.m ) THEN
173  info = -2
174  ELSE IF( k.LT.0 .OR. k.GT.n ) THEN
175  info = -3
176  ELSE IF( lda.LT.max( 1, m ) ) THEN
177  info = -5
178  ELSE IF( lwork.LT.max( 1, n ) .AND. .NOT.lquery ) THEN
179  info = -8
180  END IF
181  IF( info.NE.0 ) THEN
182  CALL xerbla( 'SORGQR', -info )
183  RETURN
184  ELSE IF( lquery ) THEN
185  RETURN
186  END IF
187 *
188 * Quick return if possible
189 *
190  IF( n.LE.0 ) THEN
191  work( 1 ) = 1
192  RETURN
193  END IF
194 *
195  nbmin = 2
196  nx = 0
197  iws = n
198  IF( nb.GT.1 .AND. nb.LT.k ) THEN
199 *
200 * Determine when to cross over from blocked to unblocked code.
201 *
202  nx = max( 0, ilaenv( 3, 'SORGQR', ' ', m, n, k, -1 ) )
203  IF( nx.LT.k ) THEN
204 *
205 * Determine if workspace is large enough for blocked code.
206 *
207  ldwork = n
208  iws = ldwork*nb
209  IF( lwork.LT.iws ) THEN
210 *
211 * Not enough workspace to use optimal NB: reduce NB and
212 * determine the minimum value of NB.
213 *
214  nb = lwork / ldwork
215  nbmin = max( 2, ilaenv( 2, 'SORGQR', ' ', m, n, k, -1 ) )
216  END IF
217  END IF
218  END IF
219 *
220  IF( nb.GE.nbmin .AND. nb.LT.k .AND. nx.LT.k ) THEN
221 *
222 * Use blocked code after the last block.
223 * The first kk columns are handled by the block method.
224 *
225  ki = ( ( k-nx-1 ) / nb )*nb
226  kk = min( k, ki+nb )
227 *
228 * Set A(1:kk,kk+1:n) to zero.
229 *
230  DO 20 j = kk + 1, n
231  DO 10 i = 1, kk
232  a( i, j ) = zero
233  10 CONTINUE
234  20 CONTINUE
235  ELSE
236  kk = 0
237  END IF
238 *
239 * Use unblocked code for the last or only block.
240 *
241  IF( kk.LT.n )
242  \$ CALL sorg2r( m-kk, n-kk, k-kk, a( kk+1, kk+1 ), lda,
243  \$ tau( kk+1 ), work, iinfo )
244 *
245  IF( kk.GT.0 ) THEN
246 *
247 * Use blocked code
248 *
249  DO 50 i = ki + 1, 1, -nb
250  ib = min( nb, k-i+1 )
251  IF( i+ib.LE.n ) THEN
252 *
253 * Form the triangular factor of the block reflector
254 * H = H(i) H(i+1) . . . H(i+ib-1)
255 *
256  CALL slarft( 'Forward', 'Columnwise', m-i+1, ib,
257  \$ a( i, i ), lda, tau( i ), work, ldwork )
258 *
259 * Apply H to A(i:m,i+ib:n) from the left
260 *
261  CALL slarfb( 'Left', 'No transpose', 'Forward',
262  \$ 'Columnwise', m-i+1, n-i-ib+1, ib,
263  \$ a( i, i ), lda, work, ldwork, a( i, i+ib ),
264  \$ lda, work( ib+1 ), ldwork )
265  END IF
266 *
267 * Apply H to rows i:m of current block
268 *
269  CALL sorg2r( m-i+1, ib, ib, a( i, i ), lda, tau( i ), work,
270  \$ iinfo )
271 *
272 * Set rows 1:i-1 of current block to zero
273 *
274  DO 40 j = i, i + ib - 1
275  DO 30 l = 1, i - 1
276  a( l, j ) = zero
277  30 CONTINUE
278  40 CONTINUE
279  50 CONTINUE
280  END IF
281 *
282  work( 1 ) = iws
283  RETURN
284 *
285 * End of SORGQR
286 *
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 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
subroutine sorg2r(M, N, K, A, LDA, TAU, WORK, INFO)
SORG2R generates all or part of the orthogonal matrix Q from a QR factorization determined by sgeqrf ...
Definition: sorg2r.f:114
Here is the call graph for this function:
Here is the caller graph for this function: