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

CUNMRZ

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