dorgtsqr()

subroutine dorgtsqr	(	integer	m,
		integer	n,
		integer	mb,
		integer	nb,
		double precision, dimension( lda, * )	a,
		integer	lda,
		double precision, dimension( ldt, * )	t,
		integer	ldt,
		double precision, dimension( * )	work,
		integer	lwork,
		integer	info )

DORGTSQR

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

Purpose:

!>
!> DORGTSQR generates an M-by-N real matrix Q_out with orthonormal columns,
!> which are the first N columns of a product of real orthogonal
!> matrices of order M which are returned by DLATSQR
!>
!>      Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ).
!>
!> See the documentation for DLATSQR.
!> 

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 used by DLATSQR to return !> arrays A and T. MB > N. !> (Note that if MB > M, then M is used instead of MB !> as the row block size). !>
[in]	NB	!> NB is INTEGER !> The column block size used by DLATSQR to return !> arrays A and T. NB >= 1. !> (Note that if NB > N, then N is used instead of NB !> as the column block size). !>
[in,out]	A	!> A is DOUBLE PRECISION array, dimension (LDA,N) !> !> On entry: !> !> The elements on and above the diagonal are not accessed. !> The elements below the diagonal represent the unit !> lower-trapezoidal blocked matrix V computed by DLATSQR !> that defines the input matrices Q_in(k) (ones on the !> diagonal are not stored) (same format as the output A !> below the diagonal in DLATSQR). !> !> On exit: !> !> The array A contains an M-by-N orthonormal matrix Q_out, !> i.e the columns of A are orthogonal unit vectors. !>
[in]	LDA	!> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !>
[in]	T	!> T is DOUBLE PRECISION array, !> dimension (LDT, N * NIRB) !> where NIRB = Number_of_input_row_blocks !> = MAX( 1, CEIL((M-N)/(MB-N)) ) !> Let NICB = Number_of_input_col_blocks !> = CEIL(N/NB) !> !> The upper-triangular block reflectors used to define the !> input matrices Q_in(k), k=(1:NIRB*NICB). The block !> reflectors are stored in compact form in NIRB block !> reflector sequences. Each of NIRB block reflector sequences !> is stored in a larger NB-by-N column block of T and consists !> of NICB smaller NB-by-NB upper-triangular column blocks. !> (same format as the output T in DLATSQR). !>
[in]	LDT	!> LDT is INTEGER !> The leading dimension of the array T. !> LDT >= max(1,min(NB1,N)). !>
[out]	WORK	!> (workspace) DOUBLE PRECISION array, dimension (MAX(2,LWORK)) !> On exit, if INFO = 0, WORK(1) returns the optimal LWORK. !>
[in]	LWORK	!> LWORK is INTEGER !> The dimension of the array WORK. LWORK >= (M+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 !>

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Contributors:

!>
!> November 2019, Igor Kozachenko,
!>                Computer Science Division,
!>                University of California, Berkeley
!>
!> 

Definition at line 172 of file dorgtsqr.f.

      IMPLICIT NONE
*
*  -- LAPACK computational routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      INTEGER           INFO, LDA, LDT, LWORK, M, N, MB, NB
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION  A( LDA, * ), T( LDT, * ), WORK( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   ONE, ZERO
      parameter( one = 1.0d+0, zero = 0.0d+0 )
*     ..
*     .. Local Scalars ..
      LOGICAL            LQUERY
      INTEGER            IINFO, LDC, LWORKOPT, LC, LW, NBLOCAL, J
*     ..
*     .. External Subroutines ..
      EXTERNAL           dcopy, dlamtsqr, dlaset, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          dble, max, min
*     ..
*     .. Executable Statements ..
*
*     Test the input parameters
*
      lquery  = lwork.EQ.-1
      info = 0
      IF( m.LT.0 ) THEN
         info = -1
      ELSE IF( n.LT.0 .OR. m.LT.n ) THEN
         info = -2
      ELSE IF( mb.LE.n ) THEN
         info = -3
      ELSE IF( nb.LT.1 ) THEN
         info = -4
      ELSE IF( lda.LT.max( 1, m ) ) THEN
         info = -6
      ELSE IF( ldt.LT.max( 1, min( nb, n ) ) ) THEN
         info = -8
      ELSE
*
*        Test the input LWORK for the dimension of the array WORK.
*        This workspace is used to store array C(LDC, N) and WORK(LWORK)
*        in the call to DLAMTSQR. See the documentation for DLAMTSQR.
*
         IF( lwork.LT.2 .AND. (.NOT.lquery) ) THEN
            info = -10
         ELSE
*
*           Set block size for column blocks
*
            nblocal = min( nb, n )
*
*           LWORK = -1, then set the size for the array C(LDC,N)
*           in DLAMTSQR call and set the optimal size of the work array
*           WORK(LWORK) in DLAMTSQR call.
*
            ldc = m
            lc = ldc*n
            lw = n * nblocal
*
            lworkopt = lc+lw
*
            IF( ( lwork.LT.max( 1, lworkopt ) ).AND.(.NOT.lquery) ) THEN
               info = -10
            END IF
         END IF
*
      END IF
*
*     Handle error in the input parameters and return workspace query.
*
      IF( info.NE.0 ) THEN
         CALL xerbla( 'DORGTSQR', -info )
         RETURN
      ELSE IF ( lquery ) THEN
         work( 1 ) = dble( lworkopt )
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( min( m, n ).EQ.0 ) THEN
         work( 1 ) = dble( lworkopt )
         RETURN
      END IF
*
*     (1) Form explicitly the tall-skinny M-by-N left submatrix Q1_in
*     of M-by-M orthogonal matrix Q_in, which is implicitly stored in
*     the subdiagonal part of input array A and in the input array T.
*     Perform by the following operation using the routine DLAMTSQR.
*
*         Q1_in = Q_in * ( I ), where I is a N-by-N identity matrix,
*                        ( 0 )        0 is a (M-N)-by-N zero matrix.
*
*     (1a) Form M-by-N matrix in the array WORK(1:LDC*N) with ones
*     on the diagonal and zeros elsewhere.
*
      CALL dlaset( 'F', m, n, zero, one, work, ldc )
*
*     (1b)  On input, WORK(1:LDC*N) stores ( I );
*                                          ( 0 )
*
*           On output, WORK(1:LDC*N) stores Q1_in.
*
      CALL dlamtsqr( 'L', 'N', m, n, n, mb, nblocal, a, lda, t, ldt,
     $               work, ldc, work( lc+1 ), lw, iinfo )
*
*     (2) Copy the result from the part of the work array (1:M,1:N)
*     with the leading dimension LDC that starts at WORK(1) into
*     the output array A(1:M,1:N) column-by-column.
*
      DO j = 1, n
         CALL dcopy( m, work( (j-1)*ldc + 1 ), 1, a( 1, j ), 1 )
      END DO
*
      work( 1 ) = dble( lworkopt )
      RETURN
*
*     End of DORGTSQR
*

Here is the call graph for this function:

Here is the caller graph for this function: