LAPACK  3.8.0
LAPACK: Linear Algebra PACKage
zlamswlq.f
Go to the documentation of this file.
1 *
2 * Definition:
3 * ===========
4 *
5 * SUBROUTINE ZLAMSWLQ( 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*16 A( LDA, * ), WORK( * ), C(LDC, * ),
15 * $ T( LDT, * )
16 *> \par Purpose:
17 * =============
18 *>
19 *> \verbatim
20 *>
21 *> ZLAMQRTS 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 = 'C': 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 (ZLASWLQ)
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': Conjugate 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*16 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 *> ZLASWLQ 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*16 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*16 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*16 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 zlamswlq( 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*16 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 ztpmlqt, zgemlqt, 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( 'ZLAMSWLQ', -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 zgemlqt( 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 *
296  IF (kk.GT.0) THEN
297  ii=m-kk+1
298  CALL ztpmlqt('L','C',kk , n, k, 0, mb, a(1,ii), lda,
299  $ t(1,ctr*k+1), ldt, c(1,1), ldc,
300  $ c(ii,1), ldc, work, info )
301  ELSE
302  ii=m+1
303  END IF
304 *
305  DO i=ii-(nb-k),nb+1,-(nb-k)
306 *
307 * Multiply Q to the current block of C (1:M,I:I+NB)
308 *
309  ctr = ctr - 1
310  CALL ztpmlqt('L','C',nb-k , n, k, 0,mb, a(1,i), lda,
311  $ t(1,ctr*k+1),ldt, c(1,1), ldc,
312  $ c(i,1), ldc, work, info )
313 
314  END DO
315 *
316 * Multiply Q to the first block of C (1:M,1:NB)
317 *
318  CALL zgemlqt('L','C',nb , n, k, mb, a(1,1), lda, t
319  $ ,ldt ,c(1,1), ldc, work, info )
320 *
321  ELSE IF (left.AND.notran) THEN
322 *
323 * Multiply Q to the first block of C
324 *
325  kk = mod((m-k),(nb-k))
326  ii=m-kk+1
327  ctr = 1
328  CALL zgemlqt('L','N',nb , n, k, mb, a(1,1), lda, t
329  $ ,ldt ,c(1,1), ldc, work, info )
330 *
331  DO i=nb+1,ii-nb+k,(nb-k)
332 *
333 * Multiply Q to the current block of C (I:I+NB,1:N)
334 *
335  CALL ztpmlqt('L','N',nb-k , n, k, 0,mb, a(1,i), lda,
336  $ t(1, ctr * k + 1), ldt, c(1,1), ldc,
337  $ c(i,1), ldc, work, info )
338  ctr = ctr + 1
339 *
340  END DO
341  IF(ii.LE.m) THEN
342 *
343 * Multiply Q to the last block of C
344 *
345  CALL ztpmlqt('L','N',kk , n, k, 0, mb, a(1,ii), lda,
346  $ t(1, ctr * k + 1), ldt, c(1,1), ldc,
347  $ c(ii,1), ldc, work, info )
348 *
349  END IF
350 *
351  ELSE IF(right.AND.notran) THEN
352 *
353 * Multiply Q to the last block of C
354 *
355  kk = mod((n-k),(nb-k))
356  ctr = (n-k)/(nb-k)
357  IF (kk.GT.0) THEN
358  ii=n-kk+1
359  CALL ztpmlqt('R','N',m , kk, k, 0, mb, a(1, ii), lda,
360  $ t(1, ctr * k + 1), ldt, c(1,1), ldc,
361  $ c(1,ii), ldc, work, info )
362  ELSE
363  ii=n+1
364  END IF
365 *
366  DO i=ii-(nb-k),nb+1,-(nb-k)
367 *
368 * Multiply Q to the current block of C (1:M,I:I+MB)
369 *
370  ctr = ctr - 1
371  CALL ztpmlqt('R','N', m, nb-k, k, 0, mb, a(1, i), lda,
372  $ t(1, ctr * k + 1), ldt, c(1,1), ldc,
373  $ c(1,i), ldc, work, info )
374 
375  END DO
376 *
377 * Multiply Q to the first block of C (1:M,1:MB)
378 *
379  CALL zgemlqt('R','N',m , nb, k, mb, a(1,1), lda, t
380  $ ,ldt ,c(1,1), ldc, work, info )
381 *
382  ELSE IF (right.AND.tran) THEN
383 *
384 * Multiply Q to the first block of C
385 *
386  kk = mod((n-k),(nb-k))
387  ii=n-kk+1
388  CALL zgemlqt('R','C',m , nb, k, mb, a(1,1), lda, t
389  $ ,ldt ,c(1,1), ldc, work, info )
390  ctr = 1
391 *
392  DO i=nb+1,ii-nb+k,(nb-k)
393 *
394 * Multiply Q to the current block of C (1:M,I:I+MB)
395 *
396  CALL ztpmlqt('R','C',m , nb-k, k, 0,mb, a(1,i), lda,
397  $ t(1,ctr *k+1), ldt, c(1,1), ldc,
398  $ c(1,i), ldc, work, info )
399  ctr = ctr + 1
400 *
401  END DO
402  IF(ii.LE.n) THEN
403 *
404 * Multiply Q to the last block of C
405 *
406  CALL ztpmlqt('R','C',m , kk, k, 0,mb, a(1,ii), lda,
407  $ t(1, ctr * k + 1),ldt, c(1,1), ldc,
408  $ c(1,ii), ldc, work, info )
409 *
410  END IF
411 *
412  END IF
413 *
414  work(1) = lw
415  RETURN
416 *
417 * End of ZLAMSWLQ
418 *
419  END
subroutine zlamswlq(SIDE, TRANS, M, N, K, MB, NB, A, LDA, T, LDT, C, LDC, WORK, LWORK, INFO)
Definition: zlamswlq.f:204
subroutine ztpmlqt(SIDE, TRANS, M, N, K, L, MB, V, LDV, T, LDT, A, LDA, B, LDB, WORK, INFO)
ZTPMLQT
Definition: ztpmlqt.f:218
subroutine zgemlqt(SIDE, TRANS, M, N, K, MB, V, LDV, T, LDT, C, LDC, WORK, INFO)
ZGEMLQT
Definition: zgemlqt.f:170
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62