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

ZUNMRZ

Purpose:
``` ZUNMRZ overwrites the general complex M-by-N matrix C with

SIDE = 'L'     SIDE = 'R'
TRANS = 'N':      Q * C          C * Q
TRANS = 'C':      Q**H * C       C * Q**H

where Q is a complex unitary matrix defined as the product of k
elementary reflectors

Q = H(1) H(2) . . . H(k)

as returned by ZTZRZF. 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**H from the Left; = 'R': apply Q or Q**H from the Right.``` [in] TRANS ``` TRANS is CHARACTER*1 = 'N': No transpose, apply Q; = 'C': Conjugate transpose, apply Q**H.``` [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 COMPLEX*16 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 ZTZRZF 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 COMPLEX*16 array, dimension (K) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZTZRZF.``` [in,out] C ``` C is COMPLEX*16 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 COMPLEX*16 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 zunmrz.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  COMPLEX*16 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 xerbla, zlarzb, zlarzt, zunmr3
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, 'C' ) ) 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, 'ZUNMRQ', 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( 'ZUNMRZ', -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 * Determine the block size. NB may be at most NBMAX, where NBMAX
294 * is used to define the local array T.
295 *
296  nb = min( nbmax, ilaenv( 1, 'ZUNMRQ', side // trans, m, n, k,
297  \$ -1 ) )
298  nbmin = 2
299  ldwork = nw
300  IF( nb.GT.1 .AND. nb.LT.k ) THEN
301  IF( lwork.LT.nw*nb+tsize ) THEN
302  nb = (lwork-tsize) / ldwork
303  nbmin = max( 2, ilaenv( 2, 'ZUNMRQ', side // trans, m, n, k,
304  \$ -1 ) )
305  END IF
306  END IF
307 *
308  IF( nb.LT.nbmin .OR. nb.GE.k ) THEN
309 *
310 * Use unblocked code
311 *
312  CALL zunmr3( side, trans, m, n, k, l, a, lda, tau, c, ldc,
313  \$ work, iinfo )
314  ELSE
315 *
316 * Use blocked code
317 *
318  iwt = 1 + nw*nb
319  IF( ( left .AND. .NOT.notran ) .OR.
320  \$ ( .NOT.left .AND. notran ) ) THEN
321  i1 = 1
322  i2 = k
323  i3 = nb
324  ELSE
325  i1 = ( ( k-1 ) / nb )*nb + 1
326  i2 = 1
327  i3 = -nb
328  END IF
329 *
330  IF( left ) THEN
331  ni = n
332  jc = 1
333  ja = m - l + 1
334  ELSE
335  mi = m
336  ic = 1
337  ja = n - l + 1
338  END IF
339 *
340  IF( notran ) THEN
341  transt = 'C'
342  ELSE
343  transt = 'N'
344  END IF
345 *
346  DO 10 i = i1, i2, i3
347  ib = min( nb, k-i+1 )
348 *
349 * Form the triangular factor of the block reflector
350 * H = H(i+ib-1) . . . H(i+1) H(i)
351 *
352  CALL zlarzt( 'Backward', 'Rowwise', l, ib, a( i, ja ), lda,
353  \$ tau( i ), work( iwt ), ldt )
354 *
355  IF( left ) THEN
356 *
357 * H or H**H is applied to C(i:m,1:n)
358 *
359  mi = m - i + 1
360  ic = i
361  ELSE
362 *
363 * H or H**H is applied to C(1:m,i:n)
364 *
365  ni = n - i + 1
366  jc = i
367  END IF
368 *
369 * Apply H or H**H
370 *
371  CALL zlarzb( side, transt, 'Backward', 'Rowwise', mi, ni,
372  \$ ib, l, a( i, ja ), lda, work( iwt ), ldt,
373  \$ c( ic, jc ), ldc, work, ldwork )
374  10 CONTINUE
375 *
376  END IF
377 *
378  work( 1 ) = lwkopt
379 *
380  RETURN
381 *
382 * End of ZUNMRZ
383 *
subroutine zlarzt(DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT)
ZLARZT forms the triangular factor T of a block reflector H = I - vtvH.
Definition: zlarzt.f:187
subroutine zunmr3(SIDE, TRANS, M, N, K, L, A, LDA, TAU, C, LDC, WORK, INFO)
ZUNMR3 multiplies a general matrix by the unitary matrix from a RZ factorization determined by ctzrzf...
Definition: zunmr3.f:180
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
Definition: tstiee.f:83
subroutine zlarzb(SIDE, TRANS, DIRECT, STOREV, M, N, K, L, V, LDV, T, LDT, C, LDC, WORK, LDWORK)
ZLARZB applies a block reflector or its conjugate-transpose to a general matrix.
Definition: zlarzb.f:185
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: