Loading...
Searching...
No Matches

## dgelq()

subroutine dgelq | ( | integer | m,
|  | integer | n,
|  | double precision, dimension( lda, * ) | a,
|  | integer | lda,
|  | double precision, dimension( * ) | t,
|  | integer | tsize,
|  | double precision, dimension( * ) | work,
|  | integer | lwork,
|  | integer | info )

DGELQ

Purpose:

      !>
      !> DGELQ 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 DOUBLE PRECISION 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 DOUBLE PRECISION 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) DOUBLE PRECISION 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
      !>                           DLASWLQ or DGELQT
      !>
      !>  Depending on the matrix dimensions M and N, and row and column
      !>  block sizes MB and NB returned by ILAENV, DGELQ will use either
      !>  DLASWLQ (if the matrix is short-and-wide) or DGELQT to compute
      !>  the LQ factorization.
      !>