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

Go to the source code of this file.

Functions/Subroutines

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

Function/Subroutine Documentation

subroutine dormlq ( 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 
)

DORMLQ

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

Purpose:
 DORMLQ 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(k) . . . H(2) H(1)

 as returned by DGELQF. 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,M) if SIDE = 'L',
                               (LDA,N) if SIDE = 'R'
          The i-th row must contain the vector which defines the
          elementary reflector H(i), for i = 1,2,...,k, as returned by
          DGELQF in the first k rows of its array argument A.
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A. LDA >= max(1,K).
[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 DGELQF.
[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 dormlq.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  CHARACTER transt
194  INTEGER i, i1, i2, i3, ib, ic, iinfo, iws, jc, ldwork,
195  $ lwkopt, mi, nb, nbmin, ni, nq, nw
196 * ..
197 * .. Local Arrays ..
198  DOUBLE PRECISION t( ldt, nbmax )
199 * ..
200 * .. External Functions ..
201  LOGICAL lsame
202  INTEGER ilaenv
203  EXTERNAL lsame, ilaenv
204 * ..
205 * .. External Subroutines ..
206  EXTERNAL dlarfb, dlarft, dorml2, xerbla
207 * ..
208 * .. Intrinsic Functions ..
209  INTRINSIC max, min
210 * ..
211 * .. Executable Statements ..
212 *
213 * Test the input arguments
214 *
215  info = 0
216  left = lsame( side, 'L' )
217  notran = lsame( trans, 'N' )
218  lquery = ( lwork.EQ.-1 )
219 *
220 * NQ is the order of Q and NW is the minimum dimension of WORK
221 *
222  IF( left ) THEN
223  nq = m
224  nw = n
225  ELSE
226  nq = n
227  nw = m
228  END IF
229  IF( .NOT.left .AND. .NOT.lsame( side, 'R' ) ) THEN
230  info = -1
231  ELSE IF( .NOT.notran .AND. .NOT.lsame( trans, 'T' ) ) THEN
232  info = -2
233  ELSE IF( m.LT.0 ) THEN
234  info = -3
235  ELSE IF( n.LT.0 ) THEN
236  info = -4
237  ELSE IF( k.LT.0 .OR. k.GT.nq ) THEN
238  info = -5
239  ELSE IF( lda.LT.max( 1, k ) ) THEN
240  info = -7
241  ELSE IF( ldc.LT.max( 1, m ) ) THEN
242  info = -10
243  ELSE IF( lwork.LT.max( 1, nw ) .AND. .NOT.lquery ) THEN
244  info = -12
245  END IF
246 *
247  IF( info.EQ.0 ) THEN
248 *
249 * Determine the block size. NB may be at most NBMAX, where NBMAX
250 * is used to define the local array T.
251 *
252  nb = min( nbmax, ilaenv( 1, 'DORMLQ', side // trans, m, n, k,
253  $ -1 ) )
254  lwkopt = max( 1, nw )*nb
255  work( 1 ) = lwkopt
256  END IF
257 *
258  IF( info.NE.0 ) THEN
259  CALL xerbla( 'DORMLQ', -info )
260  RETURN
261  ELSE IF( lquery ) THEN
262  RETURN
263  END IF
264 *
265 * Quick return if possible
266 *
267  IF( m.EQ.0 .OR. n.EQ.0 .OR. k.EQ.0 ) THEN
268  work( 1 ) = 1
269  RETURN
270  END IF
271 *
272  nbmin = 2
273  ldwork = nw
274  IF( nb.GT.1 .AND. nb.LT.k ) THEN
275  iws = nw*nb
276  IF( lwork.LT.iws ) THEN
277  nb = lwork / ldwork
278  nbmin = max( 2, ilaenv( 2, 'DORMLQ', side // trans, m, n, k,
279  $ -1 ) )
280  END IF
281  ELSE
282  iws = nw
283  END IF
284 *
285  IF( nb.LT.nbmin .OR. nb.GE.k ) THEN
286 *
287 * Use unblocked code
288 *
289  CALL dorml2( side, trans, m, n, k, a, lda, tau, c, ldc, work,
290  $ iinfo )
291  ELSE
292 *
293 * Use blocked code
294 *
295  IF( ( left .AND. notran ) .OR.
296  $ ( .NOT.left .AND. .NOT.notran ) ) THEN
297  i1 = 1
298  i2 = k
299  i3 = nb
300  ELSE
301  i1 = ( ( k-1 ) / nb )*nb + 1
302  i2 = 1
303  i3 = -nb
304  END IF
305 *
306  IF( left ) THEN
307  ni = n
308  jc = 1
309  ELSE
310  mi = m
311  ic = 1
312  END IF
313 *
314  IF( notran ) THEN
315  transt = 'T'
316  ELSE
317  transt = 'N'
318  END IF
319 *
320  DO 10 i = i1, i2, i3
321  ib = min( nb, k-i+1 )
322 *
323 * Form the triangular factor of the block reflector
324 * H = H(i) H(i+1) . . . H(i+ib-1)
325 *
326  CALL dlarft( 'Forward', 'Rowwise', nq-i+1, ib, a( i, i ),
327  $ lda, tau( i ), t, ldt )
328  IF( left ) THEN
329 *
330 * H or H**T is applied to C(i:m,1:n)
331 *
332  mi = m - i + 1
333  ic = i
334  ELSE
335 *
336 * H or H**T is applied to C(1:m,i:n)
337 *
338  ni = n - i + 1
339  jc = i
340  END IF
341 *
342 * Apply H or H**T
343 *
344  CALL dlarfb( side, transt, 'Forward', 'Rowwise', mi, ni, ib,
345  $ a( i, i ), lda, t, ldt, c( ic, jc ), ldc, work,
346  $ ldwork )
347  10 CONTINUE
348  END IF
349  work( 1 ) = lwkopt
350  RETURN
351 *
352 * End of DORMLQ
353 *
subroutine dorml2(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, INFO)
DORML2 multiplies a general matrix by the orthogonal matrix from a LQ factorization determined by sge...
Definition: dorml2.f:161
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

Here is the call graph for this function:

Here is the caller graph for this function: