LAPACK 3.12.0 LAPACK: Linear Algebra PACKage
Searching...
No Matches

## ◆ clatsqr()

 subroutine clatsqr ( integer m, integer n, integer mb, integer nb, complex, dimension( lda, * ) a, integer lda, complex, dimension(ldt, *) t, integer ldt, complex, dimension( * ) work, integer lwork, integer info )

CLATSQR

Purpose:
``` CLATSQR computes a blocked Tall-Skinny QR factorization of
a complex M-by-N matrix A for M >= N:

A = Q * ( R ),
( 0 )

where:

Q is a M-by-M orthogonal matrix, stored on exit in an implicit
form in the elements below the diagonal of the array A and in
the elements of the array T;

R is an upper-triangular N-by-N matrix, stored on exit in
the elements on and above the diagonal of the array A.

0 is a (M-N)-by-N zero matrix, and is not stored.```
Parameters
 [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 A. M >= N >= 0.``` [in] MB ``` MB is INTEGER The row block size to be used in the blocked QR. MB > N.``` [in] NB ``` NB is INTEGER The column block size to be used in the blocked QR. N >= NB >= 1.``` [in,out] A ``` A is COMPLEX array, dimension (LDA,N) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the N-by-N upper triangular matrix R; the elements below the diagonal represent Q by the columns of blocked V (see Further Details).``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).``` [out] T ``` T is COMPLEX array, dimension (LDT, N * Number_of_row_blocks) where Number_of_row_blocks = CEIL((M-N)/(MB-N)) The blocked upper triangular block reflectors stored in compact form as a sequence of upper triangular blocks. See Further Details below.``` [in] LDT ``` LDT is INTEGER The leading dimension of the array T. LDT >= NB.``` [out] WORK ` (workspace) COMPLEX array, dimension (MAX(1,LWORK))` [in] LWORK ``` LWORK is INTEGER The dimension of the array WORK. LWORK >= NB*N. 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).
For more information see Further Details in GEQRT.

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 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 167 of file clatsqr.f.

169*
170* -- LAPACK computational routine --
171* -- LAPACK is a software package provided by Univ. of Tennessee, --
172* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd. --
173*
174* .. Scalar Arguments ..
175 INTEGER INFO, LDA, M, N, MB, NB, LDT, LWORK
176* ..
177* .. Array Arguments ..
178 COMPLEX A( LDA, * ), WORK( * ), T(LDT, *)
179* ..
180*
181* =====================================================================
182*
183* ..
184* .. Local Scalars ..
185 LOGICAL LQUERY
186 INTEGER I, II, KK, CTR
187* ..
188* .. EXTERNAL FUNCTIONS ..
189 LOGICAL LSAME
190 REAL SROUNDUP_LWORK
191 EXTERNAL lsame, sroundup_lwork
192* .. EXTERNAL SUBROUTINES ..
193 EXTERNAL cgeqrt, ctpqrt, xerbla
194* .. INTRINSIC FUNCTIONS ..
195 INTRINSIC max, min, mod
196* ..
197* .. EXECUTABLE STATEMENTS ..
198*
199* TEST THE INPUT ARGUMENTS
200*
201 info = 0
202*
203 lquery = ( lwork.EQ.-1 )
204*
205 IF( m.LT.0 ) THEN
206 info = -1
207 ELSE IF( n.LT.0 .OR. m.LT.n ) THEN
208 info = -2
209 ELSE IF( mb.LT.1 ) THEN
210 info = -3
211 ELSE IF( nb.LT.1 .OR. ( nb.GT.n .AND. n.GT.0 )) THEN
212 info = -4
213 ELSE IF( lda.LT.max( 1, m ) ) THEN
214 info = -6
215 ELSE IF( ldt.LT.nb ) THEN
216 info = -8
217 ELSE IF( lwork.LT.(n*nb) .AND. (.NOT.lquery) ) THEN
218 info = -10
219 END IF
220 IF( info.EQ.0) THEN
221 work(1) = sroundup_lwork(nb*n)
222 END IF
223 IF( info.NE.0 ) THEN
224 CALL xerbla( 'CLATSQR', -info )
225 RETURN
226 ELSE IF (lquery) THEN
227 RETURN
228 END IF
229*
230* Quick return if possible
231*
232 IF( min(m,n).EQ.0 ) THEN
233 RETURN
234 END IF
235*
236* The QR Decomposition
237*
238 IF ((mb.LE.n).OR.(mb.GE.m)) THEN
239 CALL cgeqrt( m, n, nb, a, lda, t, ldt, work, info)
240 RETURN
241 END IF
242 kk = mod((m-n),(mb-n))
243 ii=m-kk+1
244*
245* Compute the QR factorization of the first block A(1:MB,1:N)
246*
247 CALL cgeqrt( mb, n, nb, a(1,1), lda, t, ldt, work, info )
248 ctr = 1
249*
250 DO i = mb+1, ii-mb+n , (mb-n)
251*
252* Compute the QR factorization of the current block A(I:I+MB-N,1:N)
253*
254 CALL ctpqrt( mb-n, n, 0, nb, a(1,1), lda, a( i, 1 ), lda,
255 \$ t(1,ctr * n + 1),
256 \$ ldt, work, info )
257 ctr = ctr + 1
258 END DO
259*
260* Compute the QR factorization of the last block A(II:M,1:N)
261*
262 IF (ii.LE.m) THEN
263 CALL ctpqrt( kk, n, 0, nb, a(1,1), lda, a( ii, 1 ), lda,
264 \$ t(1, ctr * n + 1), ldt,
265 \$ work, info )
266 END IF
267*
268 work( 1 ) = sroundup_lwork(n*nb)
269 RETURN
270*
271* End of CLATSQR
272*
subroutine xerbla(srname, info)
Definition cblat2.f:3285
subroutine cgeqrt(m, n, nb, a, lda, t, ldt, work, info)
CGEQRT
Definition cgeqrt.f:141
logical function lsame(ca, cb)
LSAME
Definition lsame.f:48
real function sroundup_lwork(lwork)
SROUNDUP_LWORK
subroutine ctpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)
CTPQRT
Definition ctpqrt.f:189
Here is the call graph for this function:
Here is the caller graph for this function: