LAPACK  3.8.0
LAPACK: Linear Algebra PACKage

◆ sormql()

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 good performance, LWORK should generally be larger.

          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
December 2016

Definition at line 170 of file sormql.f.

170 *
171 * -- LAPACK computational routine (version 3.7.0) --
172 * -- LAPACK is a software package provided by Univ. of Tennessee, --
173 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
174 * December 2016
175 *
176 * .. Scalar Arguments ..
177  CHARACTER side, trans
178  INTEGER info, k, lda, ldc, lwork, m, n
179 * ..
180 * .. Array Arguments ..
181  REAL a( lda, * ), c( ldc, * ), tau( * ),
182  $ work( * )
183 * ..
184 *
185 * =====================================================================
186 *
187 * .. Parameters ..
188  INTEGER nbmax, ldt, tsize
189  parameter( nbmax = 64, ldt = nbmax+1,
190  $ tsize = ldt*nbmax )
191 * ..
192 * .. Local Scalars ..
193  LOGICAL left, lquery, notran
194  INTEGER i, i1, i2, i3, ib, iinfo, iwt, ldwork, lwkopt,
195  $ mi, nb, nbmin, ni, nq, nw
196 * ..
197 * .. External Functions ..
198  LOGICAL lsame
199  INTEGER ilaenv
200  EXTERNAL lsame, ilaenv
201 * ..
202 * .. External Subroutines ..
203  EXTERNAL slarfb, slarft, sorm2l, xerbla
204 * ..
205 * .. Intrinsic Functions ..
206  INTRINSIC max, min
207 * ..
208 * .. Executable Statements ..
209 *
210 * Test the input arguments
211 *
212  info = 0
213  left = lsame( side, 'L' )
214  notran = lsame( trans, 'N' )
215  lquery = ( lwork.EQ.-1 )
216 *
217 * NQ is the order of Q and NW is the minimum dimension of WORK
218 *
219  IF( left ) THEN
220  nq = m
221  nw = max( 1, n )
222  ELSE
223  nq = n
224  nw = max( 1, m )
225  END IF
226  IF( .NOT.left .AND. .NOT.lsame( side, 'R' ) ) THEN
227  info = -1
228  ELSE IF( .NOT.notran .AND. .NOT.lsame( trans, 'T' ) ) THEN
229  info = -2
230  ELSE IF( m.LT.0 ) THEN
231  info = -3
232  ELSE IF( n.LT.0 ) THEN
233  info = -4
234  ELSE IF( k.LT.0 .OR. k.GT.nq ) THEN
235  info = -5
236  ELSE IF( lda.LT.max( 1, nq ) ) THEN
237  info = -7
238  ELSE IF( ldc.LT.max( 1, m ) ) THEN
239  info = -10
240  ELSE IF( lwork.LT.nw .AND. .NOT.lquery ) THEN
241  info = -12
242  END IF
243 *
244  IF( info.EQ.0 ) THEN
245 *
246 * Compute the workspace requirements
247 *
248  IF( m.EQ.0 .OR. n.EQ.0 ) THEN
249  lwkopt = 1
250  ELSE
251  nb = min( nbmax, ilaenv( 1, 'SORMQL', side // trans, m, n,
252  $ k, -1 ) )
253  lwkopt = nw*nb + tsize
254  END IF
255  work( 1 ) = lwkopt
256  END IF
257 *
258  IF( info.NE.0 ) THEN
259  CALL xerbla( 'SORMQL', -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 ) THEN
268  RETURN
269  END IF
270 *
271  nbmin = 2
272  ldwork = nw
273  IF( nb.GT.1 .AND. nb.LT.k ) THEN
274  IF( lwork.LT.nw*nb+tsize ) THEN
275  nb = (lwork-tsize) / ldwork
276  nbmin = max( 2, ilaenv( 2, 'SORMQL', side // trans, m, n, k,
277  $ -1 ) )
278  END IF
279  END IF
280 *
281  IF( nb.LT.nbmin .OR. nb.GE.k ) THEN
282 *
283 * Use unblocked code
284 *
285  CALL sorm2l( side, trans, m, n, k, a, lda, tau, c, ldc, work,
286  $ iinfo )
287  ELSE
288 *
289 * Use blocked code
290 *
291  iwt = 1 + nw*nb
292  IF( ( left .AND. notran ) .OR.
293  $ ( .NOT.left .AND. .NOT.notran ) ) THEN
294  i1 = 1
295  i2 = k
296  i3 = nb
297  ELSE
298  i1 = ( ( k-1 ) / nb )*nb + 1
299  i2 = 1
300  i3 = -nb
301  END IF
302 *
303  IF( left ) THEN
304  ni = n
305  ELSE
306  mi = m
307  END IF
308 *
309  DO 10 i = i1, i2, i3
310  ib = min( nb, k-i+1 )
311 *
312 * Form the triangular factor of the block reflector
313 * H = H(i+ib-1) . . . H(i+1) H(i)
314 *
315  CALL slarft( 'Backward', 'Columnwise', nq-k+i+ib-1, ib,
316  $ a( 1, i ), lda, tau( i ), work( iwt ), ldt )
317  IF( left ) THEN
318 *
319 * H or H**T is applied to C(1:m-k+i+ib-1,1:n)
320 *
321  mi = m - k + i + ib - 1
322  ELSE
323 *
324 * H or H**T is applied to C(1:m,1:n-k+i+ib-1)
325 *
326  ni = n - k + i + ib - 1
327  END IF
328 *
329 * Apply H or H**T
330 *
331  CALL slarfb( side, trans, 'Backward', 'Columnwise', mi, ni,
332  $ ib, a( 1, i ), lda, work( iwt ), ldt, c, ldc,
333  $ work, ldwork )
334  10 CONTINUE
335  END IF
336  work( 1 ) = lwkopt
337  RETURN
338 *
339 * End of SORMQL
340 *
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
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: tstiee.f:83
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
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
Here is the call graph for this function:
Here is the caller graph for this function: