 LAPACK  3.6.1 LAPACK: Linear Algebra PACKage
 subroutine sormrz ( character SIDE, character TRANS, integer M, integer N, integer K, integer L, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) TAU, real, dimension( ldc, * ) C, integer LDC, real, dimension( * ) WORK, integer LWORK, integer INFO )

SORMRZ

Purpose:
``` SORMRZ 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 STZRZF. 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] L ``` L is INTEGER The number of columns of the matrix A containing the meaningful part of the Householder reflectors. If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0.``` [in] A ``` A is REAL 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 STZRZF in the last k rows of its array argument A. A is modified by the routine but restored on exit.``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(1,K).``` [in] TAU ``` TAU is REAL array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by STZRZF.``` [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**H*C or C*Q**H 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```
Date
November 2015
Contributors:
A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA
Further Details:
` `

Definition at line 189 of file sormrz.f.

189 *
190 * -- LAPACK computational routine (version 3.6.0) --
191 * -- LAPACK is a software package provided by Univ. of Tennessee, --
192 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
193 * November 2015
194 *
195 * .. Scalar Arguments ..
196  CHARACTER side, trans
197  INTEGER info, k, l, lda, ldc, lwork, m, n
198 * ..
199 * .. Array Arguments ..
200  REAL a( lda, * ), c( ldc, * ), tau( * ), work( * )
201 * ..
202 *
203 * =====================================================================
204 *
205 * .. Parameters ..
206  INTEGER nbmax, ldt, tsize
207  parameter ( nbmax = 64, ldt = nbmax+1,
208  \$ tsize = ldt*nbmax )
209 * ..
210 * .. Local Scalars ..
211  LOGICAL left, lquery, notran
212  CHARACTER transt
213  INTEGER i, i1, i2, i3, ib, ic, iinfo, iwt, ja, jc,
214  \$ ldwork, lwkopt, mi, nb, nbmin, ni, nq, nw
215 * ..
216 * .. External Functions ..
217  LOGICAL lsame
218  INTEGER ilaenv
219  EXTERNAL lsame, ilaenv
220 * ..
221 * .. External Subroutines ..
222  EXTERNAL slarzb, slarzt, sormr3, xerbla
223 * ..
224 * .. Intrinsic Functions ..
225  INTRINSIC max, min
226 * ..
227 * .. Executable Statements ..
228 *
229 * Test the input arguments
230 *
231  info = 0
232  left = lsame( side, 'L' )
233  notran = lsame( trans, 'N' )
234  lquery = ( lwork.EQ.-1 )
235 *
236 * NQ is the order of Q and NW is the minimum dimension of WORK
237 *
238  IF( left ) THEN
239  nq = m
240  nw = max( 1, n )
241  ELSE
242  nq = n
243  nw = max( 1, m )
244  END IF
245  IF( .NOT.left .AND. .NOT.lsame( side, 'R' ) ) THEN
246  info = -1
247  ELSE IF( .NOT.notran .AND. .NOT.lsame( trans, 'T' ) ) THEN
248  info = -2
249  ELSE IF( m.LT.0 ) THEN
250  info = -3
251  ELSE IF( n.LT.0 ) THEN
252  info = -4
253  ELSE IF( k.LT.0 .OR. k.GT.nq ) THEN
254  info = -5
255  ELSE IF( l.LT.0 .OR. ( left .AND. ( l.GT.m ) ) .OR.
256  \$ ( .NOT.left .AND. ( l.GT.n ) ) ) THEN
257  info = -6
258  ELSE IF( lda.LT.max( 1, k ) ) THEN
259  info = -8
260  ELSE IF( ldc.LT.max( 1, m ) ) THEN
261  info = -11
262  ELSE IF( lwork.LT.max( 1, nw ) .AND. .NOT.lquery ) THEN
263  info = -13
264  END IF
265 *
266  IF( info.EQ.0 ) THEN
267 *
268 * Compute the workspace requirements
269 *
270  IF( m.EQ.0 .OR. n.EQ.0 ) THEN
271  lwkopt = 1
272  ELSE
273  nb = min( nbmax, ilaenv( 1, 'SORMRQ', side // trans, m, n,
274  \$ k, -1 ) )
275  lwkopt = nw*nb + tsize
276  END IF
277  work( 1 ) = lwkopt
278  END IF
279 *
280  IF( info.NE.0 ) THEN
281  CALL xerbla( 'SORMRZ', -info )
282  RETURN
283  ELSE IF( lquery ) THEN
284  RETURN
285  END IF
286 *
287 * Quick return if possible
288 *
289  IF( m.EQ.0 .OR. n.EQ.0 ) THEN
290  RETURN
291  END IF
292 *
293  nbmin = 2
294  ldwork = nw
295  IF( nb.GT.1 .AND. nb.LT.k ) THEN
296  IF( lwork.LT.nw*nb+tsize ) THEN
297  nb = (lwork-tsize) / ldwork
298  nbmin = max( 2, ilaenv( 2, 'SORMRQ', side // trans, m, n, k,
299  \$ -1 ) )
300  END IF
301  END IF
302 *
303  IF( nb.LT.nbmin .OR. nb.GE.k ) THEN
304 *
305 * Use unblocked code
306 *
307  CALL sormr3( side, trans, m, n, k, l, a, lda, tau, c, ldc,
308  \$ work, iinfo )
309  ELSE
310 *
311 * Use blocked code
312 *
313  iwt = 1 + nw*nb
314  IF( ( left .AND. .NOT.notran ) .OR.
315  \$ ( .NOT.left .AND. notran ) ) THEN
316  i1 = 1
317  i2 = k
318  i3 = nb
319  ELSE
320  i1 = ( ( k-1 ) / nb )*nb + 1
321  i2 = 1
322  i3 = -nb
323  END IF
324 *
325  IF( left ) THEN
326  ni = n
327  jc = 1
328  ja = m - l + 1
329  ELSE
330  mi = m
331  ic = 1
332  ja = n - l + 1
333  END IF
334 *
335  IF( notran ) THEN
336  transt = 'T'
337  ELSE
338  transt = 'N'
339  END IF
340 *
341  DO 10 i = i1, i2, i3
342  ib = min( nb, k-i+1 )
343 *
344 * Form the triangular factor of the block reflector
345 * H = H(i+ib-1) . . . H(i+1) H(i)
346 *
347  CALL slarzt( 'Backward', 'Rowwise', l, ib, a( i, ja ), lda,
348  \$ tau( i ), work( iwt ), ldt )
349 *
350  IF( left ) THEN
351 *
352 * H or H**T is applied to C(i:m,1:n)
353 *
354  mi = m - i + 1
355  ic = i
356  ELSE
357 *
358 * H or H**T is applied to C(1:m,i:n)
359 *
360  ni = n - i + 1
361  jc = i
362  END IF
363 *
364 * Apply H or H**T
365 *
366  CALL slarzb( side, transt, 'Backward', 'Rowwise', mi, ni,
367  \$ ib, l, a( i, ja ), lda, work( iwt ), ldt,
368  \$ c( ic, jc ), ldc, work, ldwork )
369  10 CONTINUE
370 *
371  END IF
372 *
373  work( 1 ) = lwkopt
374 *
375  RETURN
376 *
377 * End of SORMRZ
378 *
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
subroutine slarzb(SIDE, TRANS, DIRECT, STOREV, M, N, K, L, V, LDV, T, LDT, C, LDC, WORK, LDWORK)
SLARZB applies a block reflector or its transpose to a general matrix.
Definition: slarzb.f:185
subroutine slarzt(DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT)
SLARZT forms the triangular factor T of a block reflector H = I - vtvH.
Definition: slarzt.f:187
subroutine sormr3(SIDE, TRANS, M, N, K, L, A, LDA, TAU, C, LDC, WORK, INFO)
SORMR3 multiplies a general matrix by the orthogonal matrix from a RZ factorization determined by stz...
Definition: sormr3.f:180
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
Definition: tstiee.f:83
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55

Here is the call graph for this function:

Here is the caller graph for this function: