LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ sormrz()

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

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

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
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Contributors:
A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA
Further Details:
 

Definition at line 185 of file sormrz.f.

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