LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ zunmbr()

subroutine zunmbr ( character  VECT,
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 
)

ZUNMBR

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

Purpose:
 If VECT = 'Q', ZUNMBR 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

 If VECT = 'P', ZUNMBR overwrites the general complex M-by-N matrix C
 with
                 SIDE = 'L'     SIDE = 'R'
 TRANS = 'N':      P * C          C * P
 TRANS = 'C':      P**H * C       C * P**H

 Here Q and P**H are the unitary matrices determined by ZGEBRD when
 reducing a complex matrix A to bidiagonal form: A = Q * B * P**H. Q
 and P**H are defined as products of elementary reflectors H(i) and
 G(i) respectively.

 Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the
 order of the unitary matrix Q or P**H that is applied.

 If VECT = 'Q', A is assumed to have been an NQ-by-K matrix:
 if nq >= k, Q = H(1) H(2) . . . H(k);
 if nq < k, Q = H(1) H(2) . . . H(nq-1).

 If VECT = 'P', A is assumed to have been a K-by-NQ matrix:
 if k < nq, P = G(1) G(2) . . . G(k);
 if k >= nq, P = G(1) G(2) . . . G(nq-1).
Parameters
[in]VECT
          VECT is CHARACTER*1
          = 'Q': apply Q or Q**H;
          = 'P': apply P or P**H.
[in]SIDE
          SIDE is CHARACTER*1
          = 'L': apply Q, Q**H, P or P**H from the Left;
          = 'R': apply Q, Q**H, P or P**H from the Right.
[in]TRANS
          TRANS is CHARACTER*1
          = 'N':  No transpose, apply Q or P;
          = 'C':  Conjugate transpose, apply Q**H or P**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
          If VECT = 'Q', the number of columns in the original
          matrix reduced by ZGEBRD.
          If VECT = 'P', the number of rows in the original
          matrix reduced by ZGEBRD.
          K >= 0.
[in]A
          A is COMPLEX*16 array, dimension
                                (LDA,min(nq,K)) if VECT = 'Q'
                                (LDA,nq)        if VECT = 'P'
          The vectors which define the elementary reflectors H(i) and
          G(i), whose products determine the matrices Q and P, as
          returned by ZGEBRD.
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A.
          If VECT = 'Q', LDA >= max(1,nq);
          if VECT = 'P', LDA >= max(1,min(nq,K)).
[in]TAU
          TAU is COMPLEX*16 array, dimension (min(nq,K))
          TAU(i) must contain the scalar factor of the elementary
          reflector H(i) or G(i) which determines Q or P, as returned
          by ZGEBRD in the array argument TAUQ or TAUP.
[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
          or P*C or P**H*C or C*P or C*P**H.
[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);
          if N = 0 or M = 0, LWORK >= 1.
          For optimum performance LWORK >= max(1,N*NB) if SIDE = 'L',
          and LWORK >= max(1,M*NB) if SIDE = 'R', where NB is the
          optimal blocksize. (NB = 0 if M = 0 or N = 0.)

          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.

Definition at line 194 of file zunmbr.f.

196 *
197 * -- LAPACK computational routine --
198 * -- LAPACK is a software package provided by Univ. of Tennessee, --
199 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
200 *
201 * .. Scalar Arguments ..
202  CHARACTER SIDE, TRANS, VECT
203  INTEGER INFO, K, LDA, LDC, LWORK, M, N
204 * ..
205 * .. Array Arguments ..
206  COMPLEX*16 A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )
207 * ..
208 *
209 * =====================================================================
210 *
211 * .. Local Scalars ..
212  LOGICAL APPLYQ, LEFT, LQUERY, NOTRAN
213  CHARACTER TRANST
214  INTEGER I1, I2, IINFO, LWKOPT, MI, NB, NI, NQ, NW
215 * ..
216 * .. External Functions ..
217  LOGICAL LSAME
218  INTEGER ILAENV
219  EXTERNAL lsame, ilaenv
220 * ..
221 * .. External Subroutines ..
222  EXTERNAL xerbla, zunmlq, zunmqr
223 * ..
224 * .. Intrinsic Functions ..
225  INTRINSIC max, min
226 * ..
227 * .. Executable Statements ..
228 *
229 * Test the input arguments
230 *
231  info = 0
232  applyq = lsame( vect, 'Q' )
233  left = lsame( side, 'L' )
234  notran = lsame( trans, 'N' )
235  lquery = ( lwork.EQ.-1 )
236 *
237 * NQ is the order of Q or P and NW is the minimum dimension of WORK
238 *
239  IF( left ) THEN
240  nq = m
241  nw = max( 1, n )
242  ELSE
243  nq = n
244  nw = max( 1, m )
245  END IF
246  IF( .NOT.applyq .AND. .NOT.lsame( vect, 'P' ) ) THEN
247  info = -1
248  ELSE IF( .NOT.left .AND. .NOT.lsame( side, 'R' ) ) THEN
249  info = -2
250  ELSE IF( .NOT.notran .AND. .NOT.lsame( trans, 'C' ) ) THEN
251  info = -3
252  ELSE IF( m.LT.0 ) THEN
253  info = -4
254  ELSE IF( n.LT.0 ) THEN
255  info = -5
256  ELSE IF( k.LT.0 ) THEN
257  info = -6
258  ELSE IF( ( applyq .AND. lda.LT.max( 1, nq ) ) .OR.
259  $ ( .NOT.applyq .AND. lda.LT.max( 1, min( nq, k ) ) ) )
260  $ THEN
261  info = -8
262  ELSE IF( ldc.LT.max( 1, m ) ) THEN
263  info = -11
264  ELSE IF( lwork.LT.nw .AND. .NOT.lquery ) THEN
265  info = -13
266  END IF
267 *
268  IF( info.EQ.0 ) THEN
269  IF( m.GT.0 .AND. n.GT.0 ) THEN
270  IF( applyq ) THEN
271  IF( left ) THEN
272  nb = ilaenv( 1, 'ZUNMQR', side // trans, m-1, n, m-1,
273  $ -1 )
274  ELSE
275  nb = ilaenv( 1, 'ZUNMQR', side // trans, m, n-1, n-1,
276  $ -1 )
277  END IF
278  ELSE
279  IF( left ) THEN
280  nb = ilaenv( 1, 'ZUNMLQ', side // trans, m-1, n, m-1,
281  $ -1 )
282  ELSE
283  nb = ilaenv( 1, 'ZUNMLQ', side // trans, m, n-1, n-1,
284  $ -1 )
285  END IF
286  END IF
287  lwkopt = nw*nb
288  ELSE
289  lwkopt = 1
290  END IF
291  work( 1 ) = lwkopt
292  END IF
293 *
294  IF( info.NE.0 ) THEN
295  CALL xerbla( 'ZUNMBR', -info )
296  RETURN
297  ELSE IF( lquery ) THEN
298  RETURN
299  END IF
300 *
301 * Quick return if possible
302 *
303  IF( m.EQ.0 .OR. n.EQ.0 )
304  $ RETURN
305 *
306  IF( applyq ) THEN
307 *
308 * Apply Q
309 *
310  IF( nq.GE.k ) THEN
311 *
312 * Q was determined by a call to ZGEBRD with nq >= k
313 *
314  CALL zunmqr( side, trans, m, n, k, a, lda, tau, c, ldc,
315  $ work, lwork, iinfo )
316  ELSE IF( nq.GT.1 ) THEN
317 *
318 * Q was determined by a call to ZGEBRD with nq < k
319 *
320  IF( left ) THEN
321  mi = m - 1
322  ni = n
323  i1 = 2
324  i2 = 1
325  ELSE
326  mi = m
327  ni = n - 1
328  i1 = 1
329  i2 = 2
330  END IF
331  CALL zunmqr( side, trans, mi, ni, nq-1, a( 2, 1 ), lda, tau,
332  $ c( i1, i2 ), ldc, work, lwork, iinfo )
333  END IF
334  ELSE
335 *
336 * Apply P
337 *
338  IF( notran ) THEN
339  transt = 'C'
340  ELSE
341  transt = 'N'
342  END IF
343  IF( nq.GT.k ) THEN
344 *
345 * P was determined by a call to ZGEBRD with nq > k
346 *
347  CALL zunmlq( side, transt, m, n, k, a, lda, tau, c, ldc,
348  $ work, lwork, iinfo )
349  ELSE IF( nq.GT.1 ) THEN
350 *
351 * P was determined by a call to ZGEBRD with nq <= k
352 *
353  IF( left ) THEN
354  mi = m - 1
355  ni = n
356  i1 = 2
357  i2 = 1
358  ELSE
359  mi = m
360  ni = n - 1
361  i1 = 1
362  i2 = 2
363  END IF
364  CALL zunmlq( side, transt, mi, ni, nq-1, a( 1, 2 ), lda,
365  $ tau, c( i1, i2 ), ldc, work, lwork, iinfo )
366  END IF
367  END IF
368  work( 1 ) = lwkopt
369  RETURN
370 *
371 * End of ZUNMBR
372 *
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 zunmlq(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
ZUNMLQ
Definition: zunmlq.f:167
subroutine zunmqr(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
ZUNMQR
Definition: zunmqr.f:167
Here is the call graph for this function:
Here is the caller graph for this function: