LAPACK  3.8.0
LAPACK: Linear Algebra PACKage

◆ zunmrz()

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

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

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
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
December 2016
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.7.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 * December 2016
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 *
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
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 xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
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
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
Here is the call graph for this function:
Here is the caller graph for this function: