LAPACK  3.9.0
LAPACK: Linear Algebra PACKage

◆ zlamswlq()

subroutine zlamswlq ( character  SIDE,
character  TRANS,
integer  M,
integer  N,
integer  K,
integer  MB,
integer  NB,
complex*16, dimension( lda, * )  A,
integer  LDA,
complex*16, dimension( ldt, * )  T,
integer  LDT,
complex*16, dimension(ldc, * )  C,
integer  LDC,
complex*16, dimension( * )  WORK,
integer  LWORK,
integer  INFO 
)

ZLAMSWLQ

Purpose:
    ZLAMQRTS overwrites the general real 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 real orthogonal matrix defined as the product of blocked
    elementary reflectors computed by short wide LQ
    factorization (ZLASWLQ)
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 >= M.
[in]K
          K is INTEGER
          The number of elementary reflectors whose product defines
          the matrix Q.
          M >= K >= 0;
[in]MB
          MB is INTEGER
          The row block size to be used in the blocked QR.
          M >= MB >= 1
[in]NB
          NB is INTEGER
          The column block size to be used in the blocked QR.
          NB > M.
[in]NB
          NB is INTEGER
          The block size to be used in the blocked QR.
                MB > M.
[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 blocked
          elementary reflector H(i), for i = 1,2,...,k, as returned by
          ZLASWLQ in the first k rows of its array argument A.
[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
          ( M * Number of blocks(CEIL(N-K/NB-K)),
          The blocked upper triangular block reflectors stored in compact form
          as a sequence of upper triangular blocks.  See below
          for further details.
[in]LDT
          LDT is INTEGER
          The leading dimension of the array T.  LDT >= MB.
[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
         (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))
[in]LWORK
          LWORK is INTEGER
          The dimension of the array WORK.
          If SIDE = 'L', LWORK >= max(1,NB) * MB;
          if SIDE = 'R', LWORK >= max(1,M) * MB.
          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.
Further Details:
 Short-Wide LQ (SWLQ) performs LQ by a sequence of orthogonal transformations,
 representing Q as a product of other orthogonal matrices
   Q = Q(1) * Q(2) * . . . * Q(k)
 where each Q(i) zeros out upper diagonal entries of a block of NB rows of A:
   Q(1) zeros out the upper diagonal entries of rows 1:NB of A
   Q(2) zeros out the bottom MB-N rows of rows [1:M,NB+1:2*NB-M] of A
   Q(3) zeros out the bottom MB-N rows of rows [1:M,2*NB-M+1:3*NB-2*M] of A
   . . .

 Q(1) is computed by GELQT, which represents Q(1) by Householder vectors
 stored under the diagonal of rows 1:MB of A, and by upper triangular
 block reflectors, stored in array T(1:LDT,1:N).
 For more information see Further Details in GELQT.

 Q(i) for i>1 is computed by TPLQT, which represents Q(i) by Householder vectors
 stored in columns [(i-1)*(NB-M)+M+1:i*(NB-M)+M] of A, and by upper triangular
 block reflectors, stored in array T(1:LDT,(i-1)*M+1:i*M).
 The last Q(k) may use fewer rows.
 For more information see Further Details in TPQRT.

 For more details of the overall algorithm, see the description of
 Sequential TSQR in Section 2.2 of [1].

 [1] “Communication-Optimal Parallel and Sequential QR and LU Factorizations,”
     J. Demmel, L. Grigori, M. Hoemmen, J. Langou,
     SIAM J. Sci. Comput, vol. 34, no. 1, 2012

Definition at line 205 of file zlamswlq.f.

205 *
206 * -- LAPACK computational routine (version 3.7.1) --
207 * -- LAPACK is a software package provided by Univ. of Tennessee, --
208 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
209 * June 2017
210 *
211 * .. Scalar Arguments ..
212  CHARACTER SIDE, TRANS
213  INTEGER INFO, LDA, M, N, K, MB, NB, LDT, LWORK, LDC
214 * ..
215 * .. Array Arguments ..
216  COMPLEX*16 A( LDA, * ), WORK( * ), C(LDC, * ),
217  $ T( LDT, * )
218 * ..
219 *
220 * =====================================================================
221 *
222 * ..
223 * .. Local Scalars ..
224  LOGICAL LEFT, RIGHT, TRAN, NOTRAN, LQUERY
225  INTEGER I, II, KK, LW, CTR
226 * ..
227 * .. External Functions ..
228  LOGICAL LSAME
229  EXTERNAL lsame
230 * .. External Subroutines ..
231  EXTERNAL ztpmlqt, zgemlqt, xerbla
232 * ..
233 * .. Executable Statements ..
234 *
235 * Test the input arguments
236 *
237  lquery = lwork.LT.0
238  notran = lsame( trans, 'N' )
239  tran = lsame( trans, 'C' )
240  left = lsame( side, 'L' )
241  right = lsame( side, 'R' )
242  IF (left) THEN
243  lw = n * mb
244  ELSE
245  lw = m * mb
246  END IF
247 *
248  info = 0
249  IF( .NOT.left .AND. .NOT.right ) THEN
250  info = -1
251  ELSE IF( .NOT.tran .AND. .NOT.notran ) THEN
252  info = -2
253  ELSE IF( m.LT.0 ) THEN
254  info = -3
255  ELSE IF( n.LT.0 ) THEN
256  info = -4
257  ELSE IF( k.LT.0 ) THEN
258  info = -5
259  ELSE IF( lda.LT.max( 1, k ) ) THEN
260  info = -9
261  ELSE IF( ldt.LT.max( 1, mb) ) THEN
262  info = -11
263  ELSE IF( ldc.LT.max( 1, m ) ) THEN
264  info = -13
265  ELSE IF(( lwork.LT.max(1,lw)).AND.(.NOT.lquery)) THEN
266  info = -15
267  END IF
268 *
269  IF( info.NE.0 ) THEN
270  CALL xerbla( 'ZLAMSWLQ', -info )
271  work(1) = lw
272  RETURN
273  ELSE IF (lquery) THEN
274  work(1) = lw
275  RETURN
276  END IF
277 *
278 * Quick return if possible
279 *
280  IF( min(m,n,k).EQ.0 ) THEN
281  RETURN
282  END IF
283 *
284  IF((nb.LE.k).OR.(nb.GE.max(m,n,k))) THEN
285  CALL zgemlqt( side, trans, m, n, k, mb, a, lda,
286  $ t, ldt, c, ldc, work, info)
287  RETURN
288  END IF
289 *
290  IF(left.AND.tran) THEN
291 *
292 * Multiply Q to the last block of C
293 *
294  kk = mod((m-k),(nb-k))
295  ctr = (m-k)/(nb-k)
296 *
297  IF (kk.GT.0) THEN
298  ii=m-kk+1
299  CALL ztpmlqt('L','C',kk , n, k, 0, mb, a(1,ii), lda,
300  $ t(1,ctr*k+1), ldt, c(1,1), ldc,
301  $ c(ii,1), ldc, work, info )
302  ELSE
303  ii=m+1
304  END IF
305 *
306  DO i=ii-(nb-k),nb+1,-(nb-k)
307 *
308 * Multiply Q to the current block of C (1:M,I:I+NB)
309 *
310  ctr = ctr - 1
311  CALL ztpmlqt('L','C',nb-k , n, k, 0,mb, a(1,i), lda,
312  $ t(1,ctr*k+1),ldt, c(1,1), ldc,
313  $ c(i,1), ldc, work, info )
314 
315  END DO
316 *
317 * Multiply Q to the first block of C (1:M,1:NB)
318 *
319  CALL zgemlqt('L','C',nb , n, k, mb, a(1,1), lda, t
320  $ ,ldt ,c(1,1), ldc, work, info )
321 *
322  ELSE IF (left.AND.notran) THEN
323 *
324 * Multiply Q to the first block of C
325 *
326  kk = mod((m-k),(nb-k))
327  ii=m-kk+1
328  ctr = 1
329  CALL zgemlqt('L','N',nb , n, k, mb, a(1,1), lda, t
330  $ ,ldt ,c(1,1), ldc, work, info )
331 *
332  DO i=nb+1,ii-nb+k,(nb-k)
333 *
334 * Multiply Q to the current block of C (I:I+NB,1:N)
335 *
336  CALL ztpmlqt('L','N',nb-k , n, k, 0,mb, a(1,i), lda,
337  $ t(1, ctr * k + 1), ldt, c(1,1), ldc,
338  $ c(i,1), ldc, work, info )
339  ctr = ctr + 1
340 *
341  END DO
342  IF(ii.LE.m) THEN
343 *
344 * Multiply Q to the last block of C
345 *
346  CALL ztpmlqt('L','N',kk , n, k, 0, mb, a(1,ii), lda,
347  $ t(1, ctr * k + 1), ldt, c(1,1), ldc,
348  $ c(ii,1), ldc, work, info )
349 *
350  END IF
351 *
352  ELSE IF(right.AND.notran) THEN
353 *
354 * Multiply Q to the last block of C
355 *
356  kk = mod((n-k),(nb-k))
357  ctr = (n-k)/(nb-k)
358  IF (kk.GT.0) THEN
359  ii=n-kk+1
360  CALL ztpmlqt('R','N',m , kk, k, 0, mb, a(1, ii), lda,
361  $ t(1, ctr * k + 1), ldt, c(1,1), ldc,
362  $ c(1,ii), ldc, work, info )
363  ELSE
364  ii=n+1
365  END IF
366 *
367  DO i=ii-(nb-k),nb+1,-(nb-k)
368 *
369 * Multiply Q to the current block of C (1:M,I:I+MB)
370 *
371  ctr = ctr - 1
372  CALL ztpmlqt('R','N', m, nb-k, k, 0, mb, a(1, i), lda,
373  $ t(1, ctr * k + 1), ldt, c(1,1), ldc,
374  $ c(1,i), ldc, work, info )
375 
376  END DO
377 *
378 * Multiply Q to the first block of C (1:M,1:MB)
379 *
380  CALL zgemlqt('R','N',m , nb, k, mb, a(1,1), lda, t
381  $ ,ldt ,c(1,1), ldc, work, info )
382 *
383  ELSE IF (right.AND.tran) THEN
384 *
385 * Multiply Q to the first block of C
386 *
387  kk = mod((n-k),(nb-k))
388  ii=n-kk+1
389  CALL zgemlqt('R','C',m , nb, k, mb, a(1,1), lda, t
390  $ ,ldt ,c(1,1), ldc, work, info )
391  ctr = 1
392 *
393  DO i=nb+1,ii-nb+k,(nb-k)
394 *
395 * Multiply Q to the current block of C (1:M,I:I+MB)
396 *
397  CALL ztpmlqt('R','C',m , nb-k, k, 0,mb, a(1,i), lda,
398  $ t(1,ctr *k+1), ldt, c(1,1), ldc,
399  $ c(1,i), ldc, work, info )
400  ctr = ctr + 1
401 *
402  END DO
403  IF(ii.LE.n) THEN
404 *
405 * Multiply Q to the last block of C
406 *
407  CALL ztpmlqt('R','C',m , kk, k, 0,mb, a(1,ii), lda,
408  $ t(1, ctr * k + 1),ldt, c(1,1), ldc,
409  $ c(1,ii), ldc, work, info )
410 *
411  END IF
412 *
413  END IF
414 *
415  work(1) = lw
416  RETURN
417 *
418 * End of ZLAMSWLQ
419 *
Here is the call graph for this function:
Here is the caller graph for this function:
ztpmlqt
subroutine ztpmlqt(SIDE, TRANS, M, N, K, L, MB, V, LDV, T, LDT, A, LDA, B, LDB, WORK, INFO)
ZTPMLQT
Definition: ztpmlqt.f:218
xerbla
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
zgemlqt
subroutine zgemlqt(SIDE, TRANS, M, N, K, MB, V, LDV, T, LDT, C, LDC, WORK, INFO)
ZGEMLQT
Definition: zgemlqt.f:170
lsame
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55