sgelq()

subroutine sgelq	(	integer	m,
		integer	n,
		real, dimension( lda, * )	a,
		integer	lda,
		real, dimension( * )	t,
		integer	tsize,
		real, dimension( * )	work,
		integer	lwork,
		integer	info )

SGELQ

Purpose:

!>
!> SGELQ computes an LQ factorization of a real M-by-N matrix A:
!>
!>    A = ( L 0 ) *  Q
!>
!> where:
!>
!>    Q is a N-by-N orthogonal matrix;
!>    L is a lower-triangular M-by-M matrix;
!>    0 is a M-by-(N-M) zero matrix, if M < N.
!>
!> 

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. N >= 0. !>
[in,out]	A	!> A is REAL array, dimension (LDA,N) !> On entry, the M-by-N matrix A. !> On exit, the elements on and below the diagonal of the array !> contain the M-by-min(M,N) lower trapezoidal matrix L !> (L is lower triangular if M <= N); !> the elements above the diagonal are used to store part of the !> data structure to represent Q. !>
[in]	LDA	!> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,M). !>
[out]	T	!> T is REAL array, dimension (MAX(5,TSIZE)) !> On exit, if INFO = 0, T(1) returns optimal (or either minimal !> or optimal, if query is assumed) TSIZE. See TSIZE for details. !> Remaining T contains part of the data structure used to represent Q. !> If one wants to apply or construct Q, then one needs to keep T !> (in addition to A) and pass it to further subroutines. !>
[in]	TSIZE	!> TSIZE is INTEGER !> If TSIZE >= 5, the dimension of the array T. !> If TSIZE = -1 or -2, then a workspace query is assumed. The routine !> only calculates the sizes of the T and WORK arrays, returns these !> values as the first entries of the T and WORK arrays, and no error !> message related to T or WORK is issued by XERBLA. !> If TSIZE = -1, the routine calculates optimal size of T for the !> optimum performance and returns this value in T(1). !> If TSIZE = -2, the routine calculates minimal size of T and !> returns this value in T(1). !>
[out]	WORK	!> (workspace) REAL array, dimension (MAX(1,LWORK)) !> On exit, if INFO = 0, WORK(1) contains optimal (or either minimal !> or optimal, if query was assumed) LWORK. !> See LWORK for details. !>
[in]	LWORK	!> LWORK is INTEGER !> The dimension of the array WORK. LWORK >= 1. !> If LWORK = -1 or -2, then a workspace query is assumed. The routine !> only calculates the sizes of the T and WORK arrays, returns these !> values as the first entries of the T and WORK arrays, and no error !> message related to T or WORK is issued by XERBLA. !> If LWORK = -1, the routine calculates optimal size of WORK for the !> optimal performance and returns this value in WORK(1). !> If LWORK = -2, the routine calculates minimal size of WORK and !> returns this value in WORK(1). !>
[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.

Further Details

!>
!> The goal of the interface is to give maximum freedom to the developers for
!> creating any LQ factorization algorithm they wish. The triangular 
!> (trapezoidal) L has to be stored in the lower part of A. The lower part of A
!> and the array T can be used to store any relevant information for applying or
!> constructing the Q factor. The WORK array can safely be discarded after exit.
!>
!> Caution: One should not expect the sizes of T and WORK to be the same from one 
!> LAPACK implementation to the other, or even from one execution to the other.
!> A workspace query (for T and WORK) is needed at each execution. However, 
!> for a given execution, the size of T and WORK are fixed and will not change 
!> from one query to the next.
!>
!> 

Further Details particular to this LAPACK implementation:

!>
!> These details are particular for this LAPACK implementation. Users should not 
!> take them for granted. These details may change in the future, and are not likely
!> true for another LAPACK implementation. These details are relevant if one wants
!> to try to understand the code. They are not part of the interface.
!>
!> In this version,
!>
!>          T(2): row block size (MB)
!>          T(3): column block size (NB)
!>          T(6:TSIZE): data structure needed for Q, computed by
!>                           SLASWLQ or SGELQT
!>
!>  Depending on the matrix dimensions M and N, and row and column
!>  block sizes MB and NB returned by ILAENV, SGELQ will use either
!>  SLASWLQ (if the matrix is short-and-wide) or SGELQT to compute
!>  the LQ factorization.
!> 

Definition at line 172 of file sgelq.f.

*
*  -- 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, M, N, TSIZE, LWORK
*     ..
*     .. Array Arguments ..
      REAL               A( LDA, * ), T( * ), WORK( * )
*     ..
*
*  =====================================================================
*
*     ..
*     .. Local Scalars ..
      LOGICAL            LQUERY, LMINWS, MINT, MINW
      INTEGER            MB, NB, MINTSZ, NBLCKS, LWMIN, LWOPT, LWREQ
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      REAL               SROUNDUP_LWORK
      EXTERNAL           lsame, sroundup_lwork
*     ..
*     .. External Subroutines ..
      EXTERNAL           sgelqt, slaswlq, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max, min, mod
*     ..
*     .. External Functions ..
      INTEGER            ILAENV
      EXTERNAL           ilaenv
*     ..
*     .. Executable statements ..
*
*     Test the input arguments
*
      info = 0
*
      lquery = ( tsize.EQ.-1 .OR. tsize.EQ.-2 .OR.
     $           lwork.EQ.-1 .OR. lwork.EQ.-2 )
*
      mint = .false.
      minw = .false.
      IF( tsize.EQ.-2 .OR. lwork.EQ.-2 ) THEN
        IF( tsize.NE.-1 ) mint = .true.
        IF( lwork.NE.-1 ) minw = .true.
      END IF
*
*     Determine the block size
*
      IF( min( m, n ).GT.0 ) THEN
        mb = ilaenv( 1, 'SGELQ ', ' ', m, n, 1, -1 )
        nb = ilaenv( 1, 'SGELQ ', ' ', m, n, 2, -1 )
      ELSE
        mb = 1
        nb = n
      END IF
      IF( mb.GT.min( m, n ) .OR. mb.LT.1 ) mb = 1
      IF( nb.GT.n .OR. nb.LE.m ) nb = n
      mintsz = m + 5
      IF ( nb.GT.m .AND. n.GT.m ) THEN
        IF( mod( n - m, nb - m ).EQ.0 ) THEN
          nblcks = ( n - m ) / ( nb - m )
        ELSE
          nblcks = ( n - m ) / ( nb - m ) + 1
        END IF
      ELSE
        nblcks = 1
      END IF
*
*     Determine if the workspace size satisfies minimal size
*
      IF( ( n.LE.m ) .OR. ( nb.LE.m ) .OR. ( nb.GE.n ) ) THEN
         lwmin = max( 1, n )
         lwopt = max( 1, mb*n )
      ELSE
         lwmin = max( 1, m )
         lwopt = max( 1, mb*m )
      END IF
      lminws = .false.
      IF( ( tsize.LT.max( 1, mb*m*nblcks + 5 ) .OR. lwork.LT.lwopt )
     $    .AND. ( lwork.GE.lwmin ) .AND. ( tsize.GE.mintsz )
     $    .AND. ( .NOT.lquery ) ) THEN
        IF( tsize.LT.max( 1, mb*m*nblcks + 5 ) ) THEN
          lminws = .true.
          mb = 1
          nb = n
        END IF
        IF( lwork.LT.lwopt ) THEN
          lminws = .true.
          mb = 1
        END IF
      END IF
      IF( ( n.LE.m ) .OR. ( nb.LE.m ) .OR. ( nb.GE.n ) ) THEN
         lwreq = max( 1, mb*n )
      ELSE
         lwreq = max( 1, mb*m )
      END IF
*
      IF( m.LT.0 ) THEN
        info = -1
      ELSE IF( n.LT.0 ) THEN
        info = -2
      ELSE IF( lda.LT.max( 1, m ) ) THEN
        info = -4
      ELSE IF( tsize.LT.max( 1, mb*m*nblcks + 5 )
     $   .AND. ( .NOT.lquery ) .AND. ( .NOT.lminws ) ) THEN
        info = -6
      ELSE IF( ( lwork.LT.lwreq ) .and .( .NOT.lquery )
     $   .AND. ( .NOT.lminws ) ) THEN
        info = -8
      END IF
*
      IF( info.EQ.0 ) THEN
        IF( mint ) THEN
          t( 1 ) = real( mintsz )
        ELSE
          t( 1 ) = real( mb*m*nblcks + 5 )
        END IF
        t( 2 ) = real( mb )
        t( 3 ) = real( nb )
        IF( minw ) THEN
          work( 1 ) = sroundup_lwork( lwmin )
        ELSE
          work( 1 ) = sroundup_lwork( lwreq )
        END IF
      END IF
      IF( info.NE.0 ) THEN
        CALL xerbla( 'SGELQ', -info )
        RETURN
      ELSE IF( lquery ) THEN
        RETURN
      END IF
*
*     Quick return if possible
*
      IF( min( m, n ).EQ.0 ) THEN
        RETURN
      END IF
*
*     The LQ Decomposition
*
      IF( ( n.LE.m ) .OR. ( nb.LE.m ) .OR. ( nb.GE.n ) ) THEN
        CALL sgelqt( m, n, mb, a, lda, t( 6 ), mb, work, info )
      ELSE
        CALL slaswlq( m, n, mb, nb, a, lda, t( 6 ), mb, work,
     $                lwork, info )
      END IF
*
      work( 1 ) = sroundup_lwork( lwreq )
      RETURN
*
*     End of SGELQ
*

Here is the call graph for this function:

Here is the caller graph for this function: