LAPACK  3.5.0
LAPACK: Linear Algebra PACKage
dormqr.f File Reference

Go to the source code of this file.

Functions/Subroutines

subroutine dormqr (SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
 DORMQR More...
 

Function/Subroutine Documentation

subroutine dormqr ( character  SIDE,
character  TRANS,
integer  M,
integer  N,
integer  K,
double precision, dimension( lda, * )  A,
integer  LDA,
double precision, dimension( * )  TAU,
double precision, dimension( ldc, * )  C,
integer  LDC,
double precision, dimension( * )  WORK,
integer  LWORK,
integer  INFO 
)

DORMQR

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

Purpose:
 DORMQR overwrites the general real M-by-N matrix C with

                 SIDE = 'L'     SIDE = 'R'
 TRANS = 'N':      Q * C          C * Q
 TRANS = 'T':      Q**T * C       C * Q**T

 where Q is a real orthogonal matrix defined as the product of k
 elementary reflectors

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

 as returned by DGEQRF. Q is of order M if SIDE = 'L' and of order N
 if SIDE = 'R'.
Parameters
[in]SIDE
          SIDE is CHARACTER*1
          = 'L': apply Q or Q**T from the Left;
          = 'R': apply Q or Q**T from the Right.
[in]TRANS
          TRANS is CHARACTER*1
          = 'N':  No transpose, apply Q;
          = 'T':  Transpose, apply Q**T.
[in]M
          M is INTEGER
          The number of rows of the matrix C. M >= 0.
[in]N
          N is INTEGER
          The number of columns of the matrix C. N >= 0.
[in]K
          K is INTEGER
          The number of elementary reflectors whose product defines
          the matrix Q.
          If SIDE = 'L', M >= K >= 0;
          if SIDE = 'R', N >= K >= 0.
[in]A
          A is DOUBLE PRECISION array, dimension (LDA,K)
          The i-th column must contain the vector which defines the
          elementary reflector H(i), for i = 1,2,...,k, as returned by
          DGEQRF in the first k columns of its array argument A.
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A.
          If SIDE = 'L', LDA >= max(1,M);
          if SIDE = 'R', LDA >= max(1,N).
[in]TAU
          TAU is DOUBLE PRECISION array, dimension (K)
          TAU(i) must contain the scalar factor of the elementary
          reflector H(i), as returned by DGEQRF.
[in,out]C
          C is DOUBLE PRECISION array, dimension (LDC,N)
          On entry, the M-by-N matrix C.
          On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
[in]LDC
          LDC is INTEGER
          The leading dimension of the array C. LDC >= max(1,M).
[out]WORK
          WORK is DOUBLE PRECISION 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.
          If SIDE = 'L', LWORK >= max(1,N);
          if SIDE = 'R', LWORK >= max(1,M).
          For optimum performance LWORK >= N*NB if SIDE = 'L', and
          LWORK >= M*NB if SIDE = 'R', 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.
Date
November 2011

Definition at line 171 of file dormqr.f.

171 *
172 * -- LAPACK computational routine (version 3.4.0) --
173 * -- LAPACK is a software package provided by Univ. of Tennessee, --
174 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
175 * November 2011
176 *
177 * .. Scalar Arguments ..
178  CHARACTER side, trans
179  INTEGER info, k, lda, ldc, lwork, m, n
180 * ..
181 * .. Array Arguments ..
182  DOUBLE PRECISION a( lda, * ), c( ldc, * ), tau( * ), work( * )
183 * ..
184 *
185 * =====================================================================
186 *
187 * .. Parameters ..
188  INTEGER nbmax, ldt
189  parameter( nbmax = 64, ldt = nbmax+1 )
190 * ..
191 * .. Local Scalars ..
192  LOGICAL left, lquery, notran
193  INTEGER i, i1, i2, i3, ib, ic, iinfo, iws, jc, ldwork,
194  $ lwkopt, mi, nb, nbmin, ni, nq, nw
195 * ..
196 * .. Local Arrays ..
197  DOUBLE PRECISION t( ldt, nbmax )
198 * ..
199 * .. External Functions ..
200  LOGICAL lsame
201  INTEGER ilaenv
202  EXTERNAL lsame, ilaenv
203 * ..
204 * .. External Subroutines ..
205  EXTERNAL dlarfb, dlarft, dorm2r, xerbla
206 * ..
207 * .. Intrinsic Functions ..
208  INTRINSIC max, min
209 * ..
210 * .. Executable Statements ..
211 *
212 * Test the input arguments
213 *
214  info = 0
215  left = lsame( side, 'L' )
216  notran = lsame( trans, 'N' )
217  lquery = ( lwork.EQ.-1 )
218 *
219 * NQ is the order of Q and NW is the minimum dimension of WORK
220 *
221  IF( left ) THEN
222  nq = m
223  nw = n
224  ELSE
225  nq = n
226  nw = m
227  END IF
228  IF( .NOT.left .AND. .NOT.lsame( side, 'R' ) ) THEN
229  info = -1
230  ELSE IF( .NOT.notran .AND. .NOT.lsame( trans, 'T' ) ) THEN
231  info = -2
232  ELSE IF( m.LT.0 ) THEN
233  info = -3
234  ELSE IF( n.LT.0 ) THEN
235  info = -4
236  ELSE IF( k.LT.0 .OR. k.GT.nq ) THEN
237  info = -5
238  ELSE IF( lda.LT.max( 1, nq ) ) THEN
239  info = -7
240  ELSE IF( ldc.LT.max( 1, m ) ) THEN
241  info = -10
242  ELSE IF( lwork.LT.max( 1, nw ) .AND. .NOT.lquery ) THEN
243  info = -12
244  END IF
245 *
246  IF( info.EQ.0 ) THEN
247 *
248 * Determine the block size. NB may be at most NBMAX, where NBMAX
249 * is used to define the local array T.
250 *
251  nb = min( nbmax, ilaenv( 1, 'DORMQR', side // trans, m, n, k,
252  $ -1 ) )
253  lwkopt = max( 1, nw )*nb
254  work( 1 ) = lwkopt
255  END IF
256 *
257  IF( info.NE.0 ) THEN
258  CALL xerbla( 'DORMQR', -info )
259  RETURN
260  ELSE IF( lquery ) THEN
261  RETURN
262  END IF
263 *
264 * Quick return if possible
265 *
266  IF( m.EQ.0 .OR. n.EQ.0 .OR. k.EQ.0 ) THEN
267  work( 1 ) = 1
268  RETURN
269  END IF
270 *
271  nbmin = 2
272  ldwork = nw
273  IF( nb.GT.1 .AND. nb.LT.k ) THEN
274  iws = nw*nb
275  IF( lwork.LT.iws ) THEN
276  nb = lwork / ldwork
277  nbmin = max( 2, ilaenv( 2, 'DORMQR', side // trans, m, n, k,
278  $ -1 ) )
279  END IF
280  ELSE
281  iws = nw
282  END IF
283 *
284  IF( nb.LT.nbmin .OR. nb.GE.k ) THEN
285 *
286 * Use unblocked code
287 *
288  CALL dorm2r( side, trans, m, n, k, a, lda, tau, c, ldc, work,
289  $ iinfo )
290  ELSE
291 *
292 * Use blocked code
293 *
294  IF( ( left .AND. .NOT.notran ) .OR.
295  $ ( .NOT.left .AND. notran ) ) THEN
296  i1 = 1
297  i2 = k
298  i3 = nb
299  ELSE
300  i1 = ( ( k-1 ) / nb )*nb + 1
301  i2 = 1
302  i3 = -nb
303  END IF
304 *
305  IF( left ) THEN
306  ni = n
307  jc = 1
308  ELSE
309  mi = m
310  ic = 1
311  END IF
312 *
313  DO 10 i = i1, i2, i3
314  ib = min( nb, k-i+1 )
315 *
316 * Form the triangular factor of the block reflector
317 * H = H(i) H(i+1) . . . H(i+ib-1)
318 *
319  CALL dlarft( 'Forward', 'Columnwise', nq-i+1, ib, a( i, i ),
320  $ lda, tau( i ), t, ldt )
321  IF( left ) THEN
322 *
323 * H or H**T is applied to C(i:m,1:n)
324 *
325  mi = m - i + 1
326  ic = i
327  ELSE
328 *
329 * H or H**T is applied to C(1:m,i:n)
330 *
331  ni = n - i + 1
332  jc = i
333  END IF
334 *
335 * Apply H or H**T
336 *
337  CALL dlarfb( side, trans, 'Forward', 'Columnwise', mi, ni,
338  $ ib, a( i, i ), lda, t, ldt, c( ic, jc ), ldc,
339  $ work, ldwork )
340  10 CONTINUE
341  END IF
342  work( 1 ) = lwkopt
343  RETURN
344 *
345 * End of DORMQR
346 *
subroutine dlarft(DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT)
DLARFT forms the triangular factor T of a block reflector H = I - vtvH
Definition: dlarft.f:165
subroutine dlarfb(SIDE, TRANS, DIRECT, STOREV, M, N, K, V, LDV, T, LDT, C, LDC, WORK, LDWORK)
DLARFB applies a block reflector or its transpose to a general rectangular matrix.
Definition: dlarfb.f:197
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
Definition: tstiee.f:83
subroutine dorm2r(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, INFO)
DORM2R multiplies a general matrix by the orthogonal matrix from a QR factorization determined by sge...
Definition: dorm2r.f:161

Here is the call graph for this function:

Here is the caller graph for this function: