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

Go to the source code of this file.

Functions/Subroutines

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

Function/Subroutine Documentation

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

SORMQL

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

Purpose:
 SORMQL 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 SGEQLF. 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 REAL 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
          SGEQLF in the last 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 REAL array, dimension (K)
          TAU(i) must contain the scalar factor of the elementary
          reflector H(i), as returned by SGEQLF.
[in,out]C
          C is REAL 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 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.
          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 172 of file sormql.f.

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

Here is the call graph for this function:

Here is the caller graph for this function: