LAPACK  3.8.0
LAPACK: Linear Algebra PACKage

◆ zgemqr()

subroutine zgemqr ( character  SIDE,
character  TRANS,
integer  M,
integer  N,
integer  K,
complex*16, dimension( lda, * )  A,
integer  LDA,
complex*16, dimension( * )  T,
integer  TSIZE,
complex*16, dimension( ldc, * )  C,
integer  LDC,
complex*16, dimension( * )  WORK,
integer  LWORK,
integer  INFO 
)
Purpose:

ZGEMQR overwrites the general real M-by-N matrix C with

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

where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (ZGEQR)

Parameters
[in]SIDE
          SIDE is CHARACTER*1
          = 'L': apply Q or Q**T from the Left;
          = 'R': apply Q or Q**T from the Right.
[in]TRANS
          TRANS is CHARACTER*1
          = 'N':  No transpose, apply Q;
          = 'T':  Transpose, apply Q**T.
[in]M
          M is INTEGER
          The number of rows of the matrix A.  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,K)
          Part of the data structure to represent Q as returned by ZGEQR.
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A.
          If SIDE = 'L', LDA >= max(1,M);
          if SIDE = 'R', LDA >= max(1,N).
[in]T
          T is COMPLEX*16 array, dimension (MAX(5,TSIZE)).
          Part of the data structure to represent Q as returned by ZGEQR.
[in]TSIZE
          TSIZE is INTEGER
          The dimension of the array T. TSIZE >= 5.
[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**T*C or C*Q**T or C*Q.
[in]LDC
          LDC is INTEGER
          The leading dimension of the array C. LDC >= max(1,M).
[out]WORK
         (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))
[in]LWORK
          LWORK is INTEGER
          The dimension of the array WORK.
          If LWORK = -1, then a workspace query is assumed. The routine
          only calculates the size of the WORK array, returns this
          value as WORK(1), and no error message related to WORK 
          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.
Further Details

These details are particular for this LAPACK implementation. Users should not take them for granted. These details may change in the future, and are unlikely not true for another LAPACK implementation. These details are relevant if one wants to try to understand the code. They are not part of the interface.

In this version,

T(2): row block size (MB) T(3): column block size (NB) T(6:TSIZE): data structure needed for Q, computed by ZLATSQR or ZGEQRT

Depending on the matrix dimensions M and N, and row and column block sizes MB and NB returned by ILAENV, ZGEQR will use either ZLATSQR (if the matrix is tall-and-skinny) or ZGEQRT to compute the QR factorization. This version of ZGEMQR will use either ZLAMTSQR or ZGEMQRT to multiply matrix Q by another matrix. Further Details in ZLAMTSQR or ZGEMQRT.

Definition at line 171 of file zgemqr.f.

171 *
172 * -- LAPACK computational routine (version 3.7.0) --
173 * -- LAPACK is a software package provided by Univ. of Tennessee, --
174 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
175 * December 2016
176 *
177 * .. Scalar Arguments ..
178  CHARACTER side, trans
179  INTEGER info, lda, m, n, k, tsize, lwork, ldc
180 * ..
181 * .. Array Arguments ..
182  COMPLEX*16 a( lda, * ), t( * ), c( ldc, * ), work( * )
183 * ..
184 *
185 * =====================================================================
186 *
187 * ..
188 * .. Local Scalars ..
189  LOGICAL left, right, tran, notran, lquery
190  INTEGER mb, nb, lw, nblcks, mn
191 * ..
192 * .. External Functions ..
193  LOGICAL lsame
194  EXTERNAL lsame
195 * ..
196 * .. External Subroutines ..
197  EXTERNAL zgemqrt, zlamtsqr, xerbla
198 * ..
199 * .. Intrinsic Functions ..
200  INTRINSIC int, max, min, mod
201 * ..
202 * .. Executable Statements ..
203 *
204 * Test the input arguments
205 *
206  lquery = lwork.EQ.-1
207  notran = lsame( trans, 'N' )
208  tran = lsame( trans, 'C' )
209  left = lsame( side, 'L' )
210  right = lsame( side, 'R' )
211 *
212  mb = int( t( 2 ) )
213  nb = int( t( 3 ) )
214  IF( left ) THEN
215  lw = n * nb
216  mn = m
217  ELSE
218  lw = mb * nb
219  mn = n
220  END IF
221 *
222  IF( ( mb.GT.k ) .AND. ( mn.GT.k ) ) THEN
223  IF( mod( mn - k, mb - k ).EQ.0 ) THEN
224  nblcks = ( mn - k ) / ( mb - k )
225  ELSE
226  nblcks = ( mn - k ) / ( mb - k ) + 1
227  END IF
228  ELSE
229  nblcks = 1
230  END IF
231 *
232  info = 0
233  IF( .NOT.left .AND. .NOT.right ) THEN
234  info = -1
235  ELSE IF( .NOT.tran .AND. .NOT.notran ) THEN
236  info = -2
237  ELSE IF( m.LT.0 ) THEN
238  info = -3
239  ELSE IF( n.LT.0 ) THEN
240  info = -4
241  ELSE IF( k.LT.0 .OR. k.GT.mn ) THEN
242  info = -5
243  ELSE IF( lda.LT.max( 1, mn ) ) THEN
244  info = -7
245  ELSE IF( tsize.LT.5 ) THEN
246  info = -9
247  ELSE IF( ldc.LT.max( 1, m ) ) THEN
248  info = -11
249  ELSE IF( ( lwork.LT.max( 1, lw ) ) .AND. ( .NOT.lquery ) ) THEN
250  info = -13
251  END IF
252 *
253  IF( info.EQ.0 ) THEN
254  work( 1 ) = lw
255  END IF
256 *
257  IF( info.NE.0 ) THEN
258  CALL xerbla( 'ZGEMQR', -info )
259  RETURN
260  ELSE IF( lquery ) THEN
261  RETURN
262  END IF
263 *
264 * Quick return if possible
265 *
266  IF( min( m, n, k ).EQ.0 ) THEN
267  RETURN
268  END IF
269 *
270  IF( ( left .AND. m.LE.k ) .OR. ( right .AND. n.LE.k )
271  $ .OR. ( mb.LE.k ) .OR. ( mb.GE.max( m, n, k ) ) ) THEN
272  CALL zgemqrt( side, trans, m, n, k, nb, a, lda, t( 6 ),
273  $ nb, c, ldc, work, info )
274  ELSE
275  CALL zlamtsqr( side, trans, m, n, k, mb, nb, a, lda, t( 6 ),
276  $ nb, c, ldc, work, lwork, info )
277  END IF
278 *
279  work( 1 ) = lw
280 *
281  RETURN
282 *
283 * End of ZGEMQR
284 *
subroutine zgemqrt(SIDE, TRANS, M, N, K, NB, V, LDV, T, LDT, C, LDC, WORK, INFO)
ZGEMQRT
Definition: zgemqrt.f:170
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
subroutine zlamtsqr(SIDE, TRANS, M, N, K, MB, NB, A, LDA, T, LDT, C, LDC, WORK, LWORK, INFO)
Definition: zlamtsqr.f:197
Here is the call graph for this function:
Here is the caller graph for this function: