 LAPACK  3.10.0 LAPACK: Linear Algebra PACKage

## ◆ clamtsqr()

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

CLAMTSQR

Purpose:
```      CLAMTSQR 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 real orthogonal matrix defined as the product
of blocked elementary reflectors computed by tall skinny
QR factorization (CLATSQR)```
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 A. M >=0.``` [in] N ``` N is INTEGER The number of columns of the matrix C. M >= N >= 0.``` [in] K ``` K is INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0;``` [in] MB ``` MB is INTEGER The block size to be used in the blocked QR. MB > N. (must be the same as DLATSQR)``` [in] NB ``` NB is INTEGER The column block size to be used in the blocked QR. N >= NB >= 1.``` [in] A ``` A is COMPLEX array, dimension (LDA,K) The i-th column must contain the vector which defines the blockedelementary reflector H(i), for i = 1,2,...,k, as returned by DLATSQR in the first k columns 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 array, dimension ( N * Number of blocks(CEIL(M-K/MB-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 >= NB.``` [in,out] C ``` C is COMPLEX 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 array, dimension (MAX(1,LWORK))` [in] LWORK ``` LWORK is INTEGER The dimension of the array WORK. If SIDE = 'L', LWORK >= max(1,N)*NB; if SIDE = 'R', LWORK >= max(1,MB)*NB. 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```
Further Details:
``` Tall-Skinny QR (TSQR) performs QR 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 subdiagonal entries of a block of MB rows of A:
Q(1) zeros out the subdiagonal entries of rows 1:MB of A
Q(2) zeros out the bottom MB-N rows of rows [1:N,MB+1:2*MB-N] of A
Q(3) zeros out the bottom MB-N rows of rows [1:N,2*MB-N+1:3*MB-2*N] of A
. . .

Q(1) is computed by GEQRT, 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).

Q(i) for i>1 is computed by TPQRT, which represents Q(i) by Householder vectors
stored in rows [(i-1)*(MB-N)+N+1:i*(MB-N)+N] of A, and by upper triangular
block reflectors, stored in array T(1:LDT,(i-1)*N+1:i*N).
The last Q(k) may use fewer rows.

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

 “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 196 of file clamtsqr.f.

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