Loading...
Searching...
No Matches

## sgelqt3()

recursive subroutine sgelqt3 | ( | integer | m,
|  | integer | n,
|  | real, dimension( lda, * ) | a,
|  | integer | lda,
|  | real, dimension( ldt, * ) | t,
|  | integer | ldt,
|  | integer | info )

SGELQT3

Purpose:

      !>
      !> SGELQT3 recursively computes a LQ factorization of a real M-by-N
      !> matrix A, using the compact WY representation of Q.
      !>
      !> Based on the algorithm of Elmroth and Gustavson,
      !> IBM J. Res. Develop. Vol 44 No. 4 July 2000.
      !>

Parameters

  [in]

  M

      !>          M is INTEGER
      !>          The number of rows of the matrix A.  M =< N.
      !>

  [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 real M-by-N matrix A.  On exit, the elements on and
      !>          below the diagonal contain the N-by-N lower triangular matrix L; the
      !>          elements above the diagonal are the rows of V.  See below for
      !>          further details.
      !>

  [in]

  LDA

      !>          LDA is INTEGER
      !>          The leading dimension of the array A.  LDA >= max(1,M).
      !>

  [out]

  T

      !>          T is REAL array, dimension (LDT,N)
      !>          The N-by-N upper triangular factor of the block reflector.
      !>          The elements on and above the diagonal contain the block
      !>          reflector T; the elements below the diagonal are not used.
      !>          See below for further details.
      !>

  [in]

  LDT

      !>          LDT is INTEGER
      !>          The leading dimension of the array T.  LDT >= max(1,N).
      !>

  [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 matrix V stores the elementary reflectors H(i) in the i-th row
      !>  above the diagonal. For example, if M=5 and N=3, the matrix V is
      !>
      !>               V = (  1  v1 v1 v1 v1 )
      !>                   (     1  v2 v2 v2 )
      !>                   (     1  v3 v3 v3 )
      !>
      !>
      !>  where the vi's represent the vectors which define H(i), which are returned
      !>  in the matrix A.  The 1's along the diagonal of V are not stored in A.  The
      !>  block reflector H is then given by
      !>
      !>               H = I - V * T * V**T
      !>
      !>  where V**T is the transpose of V.
      !>
      !>  For details of the algorithm, see Elmroth and Gustavson (cited above).
      !>