LAPACK  3.8.0
LAPACK: Linear Algebra PACKage

◆ zunmrq()

subroutine zunmrq ( character  SIDE,
character  TRANS,
integer  M,
integer  N,
integer  K,
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 
)

ZUNMRQ

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

Purpose:
 ZUNMRQ 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 H(2)**H . . . H(k)**H

 as returned by ZGERQF. 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':  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]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
          ZGERQF in the last k rows of its array argument A.
[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 ZGERQF.
[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

Definition at line 169 of file zunmrq.f.

169 *
170 * -- LAPACK computational routine (version 3.7.0) --
171 * -- LAPACK is a software package provided by Univ. of Tennessee, --
172 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
173 * December 2016
174 *
175 * .. Scalar Arguments ..
176  CHARACTER side, trans
177  INTEGER info, k, lda, ldc, lwork, m, n
178 * ..
179 * .. Array Arguments ..
180  COMPLEX*16 a( lda, * ), c( ldc, * ), tau( * ), work( * )
181 * ..
182 *
183 * =====================================================================
184 *
185 * .. Parameters ..
186  INTEGER nbmax, ldt, tsize
187  parameter( nbmax = 64, ldt = nbmax+1,
188  $ tsize = ldt*nbmax )
189 * ..
190 * .. Local Scalars ..
191  LOGICAL left, lquery, notran
192  CHARACTER transt
193  INTEGER i, i1, i2, i3, ib, iinfo, iwt, ldwork, lwkopt,
194  $ mi, nb, nbmin, ni, nq, nw
195 * ..
196 * .. External Functions ..
197  LOGICAL lsame
198  INTEGER ilaenv
199  EXTERNAL lsame, ilaenv
200 * ..
201 * .. External Subroutines ..
202  EXTERNAL xerbla, zlarfb, zlarft, zunmr2
203 * ..
204 * .. Intrinsic Functions ..
205  INTRINSIC max, min
206 * ..
207 * .. Executable Statements ..
208 *
209 * Test the input arguments
210 *
211  info = 0
212  left = lsame( side, 'L' )
213  notran = lsame( trans, 'N' )
214  lquery = ( lwork.EQ.-1 )
215 *
216 * NQ is the order of Q and NW is the minimum dimension of WORK
217 *
218  IF( left ) THEN
219  nq = m
220  nw = max( 1, n )
221  ELSE
222  nq = n
223  nw = max( 1, m )
224  END IF
225  IF( .NOT.left .AND. .NOT.lsame( side, 'R' ) ) THEN
226  info = -1
227  ELSE IF( .NOT.notran .AND. .NOT.lsame( trans, 'C' ) ) THEN
228  info = -2
229  ELSE IF( m.LT.0 ) THEN
230  info = -3
231  ELSE IF( n.LT.0 ) THEN
232  info = -4
233  ELSE IF( k.LT.0 .OR. k.GT.nq ) THEN
234  info = -5
235  ELSE IF( lda.LT.max( 1, k ) ) THEN
236  info = -7
237  ELSE IF( ldc.LT.max( 1, m ) ) THEN
238  info = -10
239  ELSE IF( lwork.LT.nw .AND. .NOT.lquery ) THEN
240  info = -12
241  END IF
242 *
243  IF( info.EQ.0 ) THEN
244 *
245 * Compute the workspace requirements
246 *
247  IF( m.EQ.0 .OR. n.EQ.0 ) THEN
248  lwkopt = 1
249  ELSE
250  nb = min( nbmax, ilaenv( 1, 'ZUNMRQ', side // trans, m, n,
251  $ k, -1 ) )
252  lwkopt = nw*nb + tsize
253  END IF
254  work( 1 ) = lwkopt
255  END IF
256 *
257  IF( info.NE.0 ) THEN
258  CALL xerbla( 'ZUNMRQ', -info )
259  RETURN
260  ELSE IF( lquery ) THEN
261  RETURN
262  END IF
263 *
264 * Quick return if possible
265 *
266  IF( m.EQ.0 .OR. n.EQ.0 ) THEN
267  RETURN
268  END IF
269 *
270  nbmin = 2
271  ldwork = nw
272  IF( nb.GT.1 .AND. nb.LT.k ) THEN
273  IF( lwork.LT.nw*nb+tsize ) THEN
274  nb = (lwork-tsize) / ldwork
275  nbmin = max( 2, ilaenv( 2, 'ZUNMRQ', side // trans, m, n, k,
276  $ -1 ) )
277  END IF
278  END IF
279 *
280  IF( nb.LT.nbmin .OR. nb.GE.k ) THEN
281 *
282 * Use unblocked code
283 *
284  CALL zunmr2( side, trans, m, n, k, a, lda, tau, c, ldc, work,
285  $ iinfo )
286  ELSE
287 *
288 * Use blocked code
289 *
290  iwt = 1 + nw*nb
291  IF( ( left .AND. .NOT.notran ) .OR.
292  $ ( .NOT.left .AND. notran ) ) THEN
293  i1 = 1
294  i2 = k
295  i3 = nb
296  ELSE
297  i1 = ( ( k-1 ) / nb )*nb + 1
298  i2 = 1
299  i3 = -nb
300  END IF
301 *
302  IF( left ) THEN
303  ni = n
304  ELSE
305  mi = m
306  END IF
307 *
308  IF( notran ) THEN
309  transt = 'C'
310  ELSE
311  transt = 'N'
312  END IF
313 *
314  DO 10 i = i1, i2, i3
315  ib = min( nb, k-i+1 )
316 *
317 * Form the triangular factor of the block reflector
318 * H = H(i+ib-1) . . . H(i+1) H(i)
319 *
320  CALL zlarft( 'Backward', 'Rowwise', nq-k+i+ib-1, ib,
321  $ a( i, 1 ), lda, tau( i ), work( iwt ), ldt )
322  IF( left ) THEN
323 *
324 * H or H**H is applied to C(1:m-k+i+ib-1,1:n)
325 *
326  mi = m - k + i + ib - 1
327  ELSE
328 *
329 * H or H**H is applied to C(1:m,1:n-k+i+ib-1)
330 *
331  ni = n - k + i + ib - 1
332  END IF
333 *
334 * Apply H or H**H
335 *
336  CALL zlarfb( side, transt, 'Backward', 'Rowwise', mi, ni,
337  $ ib, a( i, 1 ), lda, work( iwt ), ldt, c, ldc,
338  $ work, ldwork )
339  10 CONTINUE
340  END IF
341  work( 1 ) = lwkopt
342  RETURN
343 *
344 * End of ZUNMRQ
345 *
subroutine zunmr2(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, INFO)
ZUNMR2 multiplies a general matrix by the unitary matrix from a RQ factorization determined by cgerqf...
Definition: zunmr2.f:161
subroutine zlarft(DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT)
ZLARFT forms the triangular factor T of a block reflector H = I - vtvH
Definition: zlarft.f:165
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: tstiee.f:83
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
subroutine zlarfb(SIDE, TRANS, DIRECT, STOREV, M, N, K, V, LDV, T, LDT, C, LDC, WORK, LDWORK)
ZLARFB applies a block reflector or its conjugate-transpose to a general rectangular matrix...
Definition: zlarfb.f:197
Here is the call graph for this function:
Here is the caller graph for this function: