LAPACK  3.7.1
LAPACK: Linear Algebra PACKage
clamswlq.f
Go to the documentation of this file.
1 *
2 * Definition:
3 * ===========
4 *
5 * SUBROUTINE CLAMSWLQ( SIDE, TRANS, M, N, K, MB, NB, A, LDA, T,
6 * $ LDT, C, LDC, WORK, LWORK, INFO )
7 *
8 *
9 * .. Scalar Arguments ..
10 * CHARACTER SIDE, TRANS
11 * INTEGER INFO, LDA, M, N, K, MB, NB, LDT, LWORK, LDC
12 * ..
13 * .. Array Arguments ..
14 * COMPLEX A( LDA, * ), WORK( * ), C(LDC, * ),
15 * $ T( LDT, * )
16 *> \par Purpose:
17 * =============
18 *>
19 *> \verbatim
20 *>
21 *> CLAMQRTS overwrites the general real M-by-N matrix C with
22 *>
23 *>
24 *> SIDE = 'L' SIDE = 'R'
25 *> TRANS = 'N': Q * C C * Q
26 *> TRANS = 'T': Q**H * C C * Q**H
27 *> where Q is a real orthogonal matrix defined as the product of blocked
28 *> elementary reflectors computed by short wide LQ
29 *> factorization (CLASWLQ)
30 *> \endverbatim
31 *
32 * Arguments:
33 * ==========
34 *
35 *> \param[in] SIDE
36 *> \verbatim
37 *> SIDE is CHARACTER*1
38 *> = 'L': apply Q or Q**H from the Left;
39 *> = 'R': apply Q or Q**H from the Right.
40 *> \endverbatim
41 *>
42 *> \param[in] TRANS
43 *> \verbatim
44 *> TRANS is CHARACTER*1
45 *> = 'N': No transpose, apply Q;
46 *> = 'C': Transpose, apply Q**H.
47 *> \endverbatim
48 *>
49 *> \param[in] M
50 *> \verbatim
51 *> M is INTEGER
52 *> The number of rows of the matrix C. M >=0.
53 *> \endverbatim
54 *>
55 *> \param[in] N
56 *> \verbatim
57 *> N is INTEGER
58 *> The number of columns of the matrix C. N >= M.
59 *> \endverbatim
60 *>
61 *> \param[in] K
62 *> \verbatim
63 *> K is INTEGER
64 *> The number of elementary reflectors whose product defines
65 *> the matrix Q.
66 *> M >= K >= 0;
67 *>
68 *> \endverbatim
69 *> \param[in] MB
70 *> \verbatim
71 *> MB is INTEGER
72 *> The row block size to be used in the blocked QR.
73 *> M >= MB >= 1
74 *> \endverbatim
75 *>
76 *> \param[in] NB
77 *> \verbatim
78 *> NB is INTEGER
79 *> The column block size to be used in the blocked QR.
80 *> NB > M.
81 *> \endverbatim
82 *>
83 *> \param[in] NB
84 *> \verbatim
85 *> NB is INTEGER
86 *> The block size to be used in the blocked QR.
87 *> MB > M.
88 *>
89 *> \endverbatim
90 *>
91 *> \param[in] A
92 *> \verbatim
93 *> A is COMPLEX array, dimension
94 *> (LDA,M) if SIDE = 'L',
95 *> (LDA,N) if SIDE = 'R'
96 *> The i-th row must contain the vector which defines the blocked
97 *> elementary reflector H(i), for i = 1,2,...,k, as returned by
98 *> CLASWLQ in the first k rows of its array argument A.
99 *> \endverbatim
100 *>
101 *> \param[in] LDA
102 *> \verbatim
103 *> LDA is INTEGER
104 *> The leading dimension of the array A.
105 *> If SIDE = 'L', LDA >= max(1,M);
106 *> if SIDE = 'R', LDA >= max(1,N).
107 *> \endverbatim
108 *>
109 *> \param[in] T
110 *> \verbatim
111 *> T is COMPLEX array, dimension
112 *> ( M * Number of blocks(CEIL(N-K/NB-K)),
113 *> The blocked upper triangular block reflectors stored in compact form
114 *> as a sequence of upper triangular blocks. See below
115 *> for further details.
116 *> \endverbatim
117 *>
118 *> \param[in] LDT
119 *> \verbatim
120 *> LDT is INTEGER
121 *> The leading dimension of the array T. LDT >= MB.
122 *> \endverbatim
123 *>
124 *> \param[in,out] C
125 *> \verbatim
126 *> C is COMPLEX array, dimension (LDC,N)
127 *> On entry, the M-by-N matrix C.
128 *> On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
129 *> \endverbatim
130 *>
131 *> \param[in] LDC
132 *> \verbatim
133 *> LDC is INTEGER
134 *> The leading dimension of the array C. LDC >= max(1,M).
135 *> \endverbatim
136 *>
137 *> \param[out] WORK
138 *> \verbatim
139 *> (workspace) COMPLEX array, dimension (MAX(1,LWORK))
140 *> \endverbatim
141 *>
142 *> \param[in] LWORK
143 *> \verbatim
144 *> LWORK is INTEGER
145 *> The dimension of the array WORK.
146 *> If SIDE = 'L', LWORK >= max(1,NB) * MB;
147 *> if SIDE = 'R', LWORK >= max(1,M) * MB.
148 *> If LWORK = -1, then a workspace query is assumed; the routine
149 *> only calculates the optimal size of the WORK array, returns
150 *> this value as the first entry of the WORK array, and no error
151 *> message related to LWORK is issued by XERBLA.
152 *> \endverbatim
153 *>
154 *> \param[out] INFO
155 *> \verbatim
156 *> INFO is INTEGER
157 *> = 0: successful exit
158 *> < 0: if INFO = -i, the i-th argument had an illegal value
159 *> \endverbatim
160 *
161 * Authors:
162 * ========
163 *
164 *> \author Univ. of Tennessee
165 *> \author Univ. of California Berkeley
166 *> \author Univ. of Colorado Denver
167 *> \author NAG Ltd.
168 *
169 *> \par Further Details:
170 * =====================
171 *>
172 *> \verbatim
173 *> Short-Wide LQ (SWLQ) performs LQ by a sequence of orthogonal transformations,
174 *> representing Q as a product of other orthogonal matrices
175 *> Q = Q(1) * Q(2) * . . . * Q(k)
176 *> where each Q(i) zeros out upper diagonal entries of a block of NB rows of A:
177 *> Q(1) zeros out the upper diagonal entries of rows 1:NB of A
178 *> Q(2) zeros out the bottom MB-N rows of rows [1:M,NB+1:2*NB-M] of A
179 *> Q(3) zeros out the bottom MB-N rows of rows [1:M,2*NB-M+1:3*NB-2*M] of A
180 *> . . .
181 *>
182 *> Q(1) is computed by GELQT, which represents Q(1) by Householder vectors
183 *> stored under the diagonal of rows 1:MB of A, and by upper triangular
184 *> block reflectors, stored in array T(1:LDT,1:N).
185 *> For more information see Further Details in GELQT.
186 *>
187 *> Q(i) for i>1 is computed by TPLQT, which represents Q(i) by Householder vectors
188 *> stored in columns [(i-1)*(NB-M)+M+1:i*(NB-M)+M] of A, and by upper triangular
189 *> block reflectors, stored in array T(1:LDT,(i-1)*M+1:i*M).
190 *> The last Q(k) may use fewer rows.
191 *> For more information see Further Details in TPQRT.
192 *>
193 *> For more details of the overall algorithm, see the description of
194 *> Sequential TSQR in Section 2.2 of [1].
195 *>
196 *> [1] “Communication-Optimal Parallel and Sequential QR and LU Factorizations,”
197 *> J. Demmel, L. Grigori, M. Hoemmen, J. Langou,
198 *> SIAM J. Sci. Comput, vol. 34, no. 1, 2012
199 *> \endverbatim
200 *>
201 * =====================================================================
202  SUBROUTINE clamswlq( SIDE, TRANS, M, N, K, MB, NB, A, LDA, T,
203  $ LDT, C, LDC, WORK, LWORK, INFO )
204 *
205 * -- LAPACK computational routine (version 3.7.1) --
206 * -- LAPACK is a software package provided by Univ. of Tennessee, --
207 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
208 * June 2017
209 *
210 * .. Scalar Arguments ..
211  CHARACTER SIDE, TRANS
212  INTEGER INFO, LDA, M, N, K, MB, NB, LDT, LWORK, LDC
213 * ..
214 * .. Array Arguments ..
215  COMPLEX A( lda, * ), WORK( * ), C(ldc, * ),
216  $ t( ldt, * )
217 * ..
218 *
219 * =====================================================================
220 *
221 * ..
222 * .. Local Scalars ..
223  LOGICAL LEFT, RIGHT, TRAN, NOTRAN, LQUERY
224  INTEGER I, II, KK, LW, CTR
225 * ..
226 * .. External Functions ..
227  LOGICAL LSAME
228  EXTERNAL lsame
229 * .. External Subroutines ..
230  EXTERNAL ctpmlqt, cgemlqt, xerbla
231 * ..
232 * .. Executable Statements ..
233 *
234 * Test the input arguments
235 *
236  lquery = lwork.LT.0
237  notran = lsame( trans, 'N' )
238  tran = lsame( trans, 'C' )
239  left = lsame( side, 'L' )
240  right = lsame( side, 'R' )
241  IF (left) THEN
242  lw = n * mb
243  ELSE
244  lw = m * mb
245  END IF
246 *
247  info = 0
248  IF( .NOT.left .AND. .NOT.right ) THEN
249  info = -1
250  ELSE IF( .NOT.tran .AND. .NOT.notran ) THEN
251  info = -2
252  ELSE IF( m.LT.0 ) THEN
253  info = -3
254  ELSE IF( n.LT.0 ) THEN
255  info = -4
256  ELSE IF( k.LT.0 ) THEN
257  info = -5
258  ELSE IF( lda.LT.max( 1, k ) ) THEN
259  info = -9
260  ELSE IF( ldt.LT.max( 1, mb) ) THEN
261  info = -11
262  ELSE IF( ldc.LT.max( 1, m ) ) THEN
263  info = -13
264  ELSE IF(( lwork.LT.max(1,lw)).AND.(.NOT.lquery)) THEN
265  info = -15
266  END IF
267 *
268  IF( info.NE.0 ) THEN
269  CALL xerbla( 'CLAMSWLQ', -info )
270  work(1) = lw
271  RETURN
272  ELSE IF (lquery) THEN
273  work(1) = lw
274  RETURN
275  END IF
276 *
277 * Quick return if possible
278 *
279  IF( min(m,n,k).EQ.0 ) THEN
280  RETURN
281  END IF
282 *
283  IF((nb.LE.k).OR.(nb.GE.max(m,n,k))) THEN
284  CALL cgemlqt( side, trans, m, n, k, mb, a, lda,
285  $ t, ldt, c, ldc, work, info)
286  RETURN
287  END IF
288 *
289  IF(left.AND.tran) THEN
290 *
291 * Multiply Q to the last block of C
292 *
293  kk = mod((m-k),(nb-k))
294  ctr = (m-k)/(nb-k)
295  IF (kk.GT.0) THEN
296  ii=m-kk+1
297  CALL ctpmlqt('L','C',kk , n, k, 0, mb, a(1,ii), lda,
298  $ t(1,ctr*k+1), ldt, c(1,1), ldc,
299  $ c(ii,1), ldc, work, info )
300  ELSE
301  ii=m+1
302  END IF
303 *
304  DO i=ii-(nb-k),nb+1,-(nb-k)
305 *
306 * Multiply Q to the current block of C (1:M,I:I+NB)
307 *
308  ctr = ctr - 1
309  CALL ctpmlqt('L','C',nb-k , n, k, 0,mb, a(1,i), lda,
310  $ t(1,ctr*k+1),ldt, c(1,1), ldc,
311  $ c(i,1), ldc, work, info )
312 
313  END DO
314 *
315 * Multiply Q to the first block of C (1:M,1:NB)
316 *
317  CALL cgemlqt('L','C',nb , n, k, mb, a(1,1), lda, t
318  $ ,ldt ,c(1,1), ldc, work, info )
319 *
320  ELSE IF (left.AND.notran) THEN
321 *
322 * Multiply Q to the first block of C
323 *
324  kk = mod((m-k),(nb-k))
325  ii = m-kk+1
326  ctr = 1
327  CALL cgemlqt('L','N',nb , n, k, mb, a(1,1), lda, t
328  $ ,ldt ,c(1,1), ldc, work, info )
329 *
330  DO i=nb+1,ii-nb+k,(nb-k)
331 *
332 * Multiply Q to the current block of C (I:I+NB,1:N)
333 *
334  CALL ctpmlqt('L','N',nb-k , n, k, 0,mb, a(1,i), lda,
335  $ t(1, ctr *k+1), ldt, c(1,1), ldc,
336  $ c(i,1), ldc, work, info )
337  ctr = ctr + 1
338 *
339  END DO
340  IF(ii.LE.m) THEN
341 *
342 * Multiply Q to the last block of C
343 *
344  CALL ctpmlqt('L','N',kk , n, k, 0, mb, a(1,ii), lda,
345  $ t(1, ctr*k+1), ldt, c(1,1), ldc,
346  $ c(ii,1), ldc, work, info )
347 *
348  END IF
349 *
350  ELSE IF(right.AND.notran) THEN
351 *
352 * Multiply Q to the last block of C
353 *
354  kk = mod((n-k),(nb-k))
355  ctr = (n-k)/(nb-k)
356  IF (kk.GT.0) THEN
357  ii=n-kk+1
358  CALL ctpmlqt('R','N',m , kk, k, 0, mb, a(1, ii), lda,
359  $ t(1,ctr*k+1), ldt, c(1,1), ldc,
360  $ c(1,ii), ldc, work, info )
361  ELSE
362  ii=n+1
363  END IF
364 *
365  DO i=ii-(nb-k),nb+1,-(nb-k)
366 *
367 * Multiply Q to the current block of C (1:M,I:I+MB)
368 *
369  ctr = ctr - 1
370  CALL ctpmlqt('R','N', m, nb-k, k, 0, mb, a(1, i), lda,
371  $ t(1,ctr*k+1), ldt, c(1,1), ldc,
372  $ c(1,i), ldc, work, info )
373  END DO
374 *
375 * Multiply Q to the first block of C (1:M,1:MB)
376 *
377  CALL cgemlqt('R','N',m , nb, k, mb, a(1,1), lda, t
378  $ ,ldt ,c(1,1), ldc, work, info )
379 *
380  ELSE IF (right.AND.tran) THEN
381 *
382 * Multiply Q to the first block of C
383 *
384  kk = mod((n-k),(nb-k))
385  ii=n-kk+1
386  ctr = 1
387  CALL cgemlqt('R','C',m , nb, k, mb, a(1,1), lda, t
388  $ ,ldt ,c(1,1), ldc, work, info )
389 *
390  DO i=nb+1,ii-nb+k,(nb-k)
391 *
392 * Multiply Q to the current block of C (1:M,I:I+MB)
393 *
394  CALL ctpmlqt('R','C',m , nb-k, k, 0,mb, a(1,i), lda,
395  $ t(1,ctr*k+1), ldt, c(1,1), ldc,
396  $ c(1,i), ldc, work, info )
397  ctr = ctr + 1
398 *
399  END DO
400  IF(ii.LE.n) THEN
401 *
402 * Multiply Q to the last block of C
403 *
404  CALL ctpmlqt('R','C',m , kk, k, 0,mb, a(1,ii), lda,
405  $ t(1,ctr*k+1),ldt, c(1,1), ldc,
406  $ c(1,ii), ldc, work, info )
407 *
408  END IF
409 *
410  END IF
411 *
412  work(1) = lw
413  RETURN
414 *
415 * End of CLAMSWLQ
416 *
417  END
ctpmlqt
subroutine ctpmlqt(SIDE, TRANS, M, N, K, L, MB, V, LDV, T, LDT, A, LDA, B, LDB, WORK, INFO)
Definition: ctpmlqt.f:201
xerbla
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
clamswlq
subroutine clamswlq(SIDE, TRANS, M, N, K, MB, NB, A, LDA, T, LDT, C, LDC, WORK, LWORK, INFO)
Definition: clamswlq.f:204
cgemlqt
subroutine cgemlqt(SIDE, TRANS, M, N, K, MB, V, LDV, T, LDT, C, LDC, WORK, INFO)
Definition: cgemlqt.f:153