LAPACK 3.12.1
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ zgetsqrhrt()

subroutine zgetsqrhrt ( integer m,
integer n,
integer mb1,
integer nb1,
integer nb2,
complex*16, dimension( lda, * ) a,
integer lda,
complex*16, dimension( ldt, * ) t,
integer ldt,
complex*16, dimension( * ) work,
integer lwork,
integer info )

ZGETSQRHRT

Download ZGETSQRHRT + dependencies [TGZ] [ZIP] [TXT]

Purpose:
!>
!> ZGETSQRHRT computes a NB2-sized column blocked QR-factorization
!> of a complex M-by-N matrix A with M >= N,
!>
!>    A = Q * R.
!>
!> The routine uses internally a NB1-sized column blocked and MB1-sized
!> row blocked TSQR-factorization and perfors the reconstruction
!> of the Householder vectors from the TSQR output. The routine also
!> converts the R_tsqr factor from the TSQR-factorization output into
!> the R factor that corresponds to the Householder QR-factorization,
!>
!>    A = Q_tsqr * R_tsqr = Q * R.
!>
!> The output Q and R factors are stored in the same format as in ZGEQRT
!> (Q is in blocked compact WY-representation). See the documentation
!> of ZGEQRT for more details on the format.
!> 
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]MB1
!>          MB1 is INTEGER
!>          The row block size to be used in the blocked TSQR.
!>          MB1 > N.
!> 
[in]NB1
!>          NB1 is INTEGER
!>          The column block size to be used in the blocked TSQR.
!>          N >= NB1 >= 1.
!> 
[in]NB2
!>          NB2 is INTEGER
!>          The block size to be used in the blocked QR that is
!>          output. NB2 >= 1.
!> 
[in,out]A
!>          A is COMPLEX*16 array, dimension (LDA,N)
!>
!>          On entry: an M-by-N matrix A.
!>
!>          On exit:
!>           a) the elements on and above the diagonal
!>              of the array contain the N-by-N upper-triangular
!>              matrix R corresponding to the Householder QR;
!>           b) the elements below the diagonal represent Q by
!>              the columns of blocked V (compact WY-representation).
!> 
[in]LDA
!>          LDA is INTEGER
!>          The leading dimension of the array A.  LDA >= max(1,M).
!> 
[out]T
!>          T is COMPLEX*16 array, dimension (LDT,N))
!>          The upper triangular block reflectors stored in compact form
!>          as a sequence of upper triangular blocks.
!> 
[in]LDT
!>          LDT is INTEGER
!>          The leading dimension of the array T.  LDT >= NB2.
!> 
[out]WORK
!>          (workspace) COMPLEX*16 array, dimension (MAX(1,LWORK))
!>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
!> 
[in]LWORK
!>          LWORK is INTEGER
!>          The dimension of the array WORK.
!>          If MIN(M,N) = 0, LWORK >= 1, else
!>          LWORK >= MAX( 1, LWT + LW1, MAX( LWT+N*N+LW2, LWT+N*N+N ) ),
!>          where
!>             NUM_ALL_ROW_BLOCKS = CEIL((M-N)/(MB1-N)),
!>             NB1LOCAL = MIN(NB1,N).
!>             LWT = NUM_ALL_ROW_BLOCKS * N * NB1LOCAL,
!>             LW1 = NB1LOCAL * N,
!>             LW2 = NB1LOCAL * MAX( NB1LOCAL, ( N - NB1LOCAL ) ).
!>
!>          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.
Contributors:
!>
!> November 2020, Igor Kozachenko,
!>                Computer Science Division,
!>                University of California, Berkeley
!>
!> 

Definition at line 178 of file zgetsqrhrt.f.

181 IMPLICIT NONE
182*
183* -- LAPACK computational routine --
184* -- LAPACK is a software package provided by Univ. of Tennessee, --
185* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
186*
187* .. Scalar Arguments ..
188 INTEGER INFO, LDA, LDT, LWORK, M, N, NB1, NB2, MB1
189* ..
190* .. Array Arguments ..
191 COMPLEX*16 A( LDA, * ), T( LDT, * ), WORK( * )
192* ..
193*
194* =====================================================================
195*
196* .. Parameters ..
197 COMPLEX*16 CONE
198 parameter( cone = ( 1.0d+0, 0.0d+0 ) )
199* ..
200* .. Local Scalars ..
201 LOGICAL LQUERY
202 INTEGER I, IINFO, J, LW1, LW2, LWT, LDWT, LWORKOPT,
203 $ NB1LOCAL, NB2LOCAL, NUM_ALL_ROW_BLOCKS
204* ..
205* .. External Subroutines ..
206 EXTERNAL zcopy, zlatsqr, zungtsqr_row,
207 $ zunhr_col,
208 $ xerbla
209* ..
210* .. Intrinsic Functions ..
211 INTRINSIC ceiling, dble, dcmplx, max, min
212* ..
213* .. Executable Statements ..
214*
215* Test the input arguments
216*
217 info = 0
218 lquery = ( lwork.EQ.-1 )
219 IF( m.LT.0 ) THEN
220 info = -1
221 ELSE IF( n.LT.0 .OR. m.LT.n ) THEN
222 info = -2
223 ELSE IF( mb1.LE.n ) THEN
224 info = -3
225 ELSE IF( nb1.LT.1 ) THEN
226 info = -4
227 ELSE IF( nb2.LT.1 ) THEN
228 info = -5
229 ELSE IF( lda.LT.max( 1, m ) ) THEN
230 info = -7
231 ELSE IF( ldt.LT.max( 1, min( nb2, n ) ) ) THEN
232 info = -9
233 ELSE
234*
235* Test the input LWORK for the dimension of the array WORK.
236* This workspace is used to store array:
237* a) Matrix T and WORK for ZLATSQR;
238* b) N-by-N upper-triangular factor R_tsqr;
239* c) Matrix T and array WORK for ZUNGTSQR_ROW;
240* d) Diagonal D for ZUNHR_COL.
241*
242 IF( lwork.LT.n*n+1 .AND. .NOT.lquery ) THEN
243 info = -11
244 ELSE
245*
246* Set block size for column blocks
247*
248 nb1local = min( nb1, n )
249*
250 num_all_row_blocks = max( 1,
251 $ ceiling( dble( m - n ) / dble( mb1 - n ) ) )
252*
253* Length and leading dimension of WORK array to place
254* T array in TSQR.
255*
256 lwt = num_all_row_blocks * n * nb1local
257
258 ldwt = nb1local
259*
260* Length of TSQR work array
261*
262 lw1 = nb1local * n
263*
264* Length of ZUNGTSQR_ROW work array.
265*
266 lw2 = nb1local * max( nb1local, ( n - nb1local ) )
267*
268 lworkopt = max( lwt + lw1, max( lwt+n*n+lw2, lwt+n*n+n ) )
269 lworkopt = max( 1, lworkopt )
270*
271 IF( lwork.LT.lworkopt .AND. .NOT.lquery ) THEN
272 info = -11
273 END IF
274*
275 END IF
276 END IF
277*
278* Handle error in the input parameters and return workspace query.
279*
280 IF( info.NE.0 ) THEN
281 CALL xerbla( 'ZGETSQRHRT', -info )
282 RETURN
283 ELSE IF ( lquery ) THEN
284 work( 1 ) = dcmplx( lworkopt )
285 RETURN
286 END IF
287*
288* Quick return if possible
289*
290 IF( min( m, n ).EQ.0 ) THEN
291 work( 1 ) = dcmplx( lworkopt )
292 RETURN
293 END IF
294*
295 nb2local = min( nb2, n )
296*
297*
298* (1) Perform TSQR-factorization of the M-by-N matrix A.
299*
300 CALL zlatsqr( m, n, mb1, nb1local, a, lda, work, ldwt,
301 $ work(lwt+1), lw1, iinfo )
302*
303* (2) Copy the factor R_tsqr stored in the upper-triangular part
304* of A into the square matrix in the work array
305* WORK(LWT+1:LWT+N*N) column-by-column.
306*
307 DO j = 1, n
308 CALL zcopy( j, a( 1, j ), 1, work( lwt + n*(j-1)+1 ), 1 )
309 END DO
310*
311* (3) Generate a M-by-N matrix Q with orthonormal columns from
312* the result stored below the diagonal in the array A in place.
313*
314
315 CALL zungtsqr_row( m, n, mb1, nb1local, a, lda, work, ldwt,
316 $ work( lwt+n*n+1 ), lw2, iinfo )
317*
318* (4) Perform the reconstruction of Householder vectors from
319* the matrix Q (stored in A) in place.
320*
321 CALL zunhr_col( m, n, nb2local, a, lda, t, ldt,
322 $ work( lwt+n*n+1 ), iinfo )
323*
324* (5) Copy the factor R_tsqr stored in the square matrix in the
325* work array WORK(LWT+1:LWT+N*N) into the upper-triangular
326* part of A.
327*
328* (6) Compute from R_tsqr the factor R_hr corresponding to
329* the reconstructed Householder vectors, i.e. R_hr = S * R_tsqr.
330* This multiplication by the sign matrix S on the left means
331* changing the sign of I-th row of the matrix R_tsqr according
332* to sign of the I-th diagonal element DIAG(I) of the matrix S.
333* DIAG is stored in WORK( LWT+N*N+1 ) from the ZUNHR_COL output.
334*
335* (5) and (6) can be combined in a single loop, so the rows in A
336* are accessed only once.
337*
338 DO i = 1, n
339 IF( work( lwt+n*n+i ).EQ.-cone ) THEN
340 DO j = i, n
341 a( i, j ) = -cone * work( lwt+n*(j-1)+i )
342 END DO
343 ELSE
344 CALL zcopy( n-i+1, work(lwt+n*(i-1)+i), n, a( i, i ),
345 $ lda )
346 END IF
347 END DO
348*
349 work( 1 ) = dcmplx( lworkopt )
350 RETURN
351*
352* End of ZGETSQRHRT
353*
subroutine xerbla(srname, info)
Definition cblat2.f:3285
subroutine zcopy(n, zx, incx, zy, incy)
ZCOPY
Definition zcopy.f:81
subroutine zlatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
ZLATSQR
Definition zlatsqr.f:172
subroutine zungtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
ZUNGTSQR_ROW
subroutine zunhr_col(m, n, nb, a, lda, t, ldt, d, info)
ZUNHR_COL
Definition zunhr_col.f:257
Here is the call graph for this function:
Here is the caller graph for this function: