cgelq()

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

CGELQ

Purpose:

 CGELQ computes an LQ factorization of a complex 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 COMPLEX 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 COMPLEX 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) COMPLEX 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. 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
                           CLASWLQ or CGELQT

  Depending on the matrix dimensions M and N, and row and column
  block sizes MB and NB returned by ILAENV, CGELQ will use either
  CLASWLQ (if the matrix is short-and-wide) or CGELQT to compute
  the LQ factorization.

Definition at line 172 of file cgelq.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 ..
      COMPLEX            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           cgelqt, claswlq, 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, 'CGELQ ', ' ', m, n, 1, -1 )
        nb = ilaenv( 1, 'CGELQ ', ' ', 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 ) = mintsz
        ELSE
          t( 1 ) = mb*m*nblcks + 5
        END IF
        t( 2 ) = mb
        t( 3 ) = 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( 'CGELQ', -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 cgelqt( m, n, mb, a, lda, t( 6 ), mb, work, info )
      ELSE
        CALL claswlq( m, n, mb, nb, a, lda, t( 6 ), mb, work,
     $                lwork, info )
      END IF
*
      work( 1 ) = sroundup_lwork(lwreq)
*
      RETURN
*
*     End of CGELQ
*

Here is the call graph for this function:

Here is the caller graph for this function: