Loading...
Searching...
No Matches

## dlatsqr()

subroutine dlatsqr | ( | 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 )

DLATSQR

Purpose:

      !>
      !> DLATSQR computes a blocked Tall-Skinny QR factorization of
      !> a real M-by-N matrix A for M >= N:
      !>
      !>    A = Q * ( R ),
      !>            ( 0 )
      !>
      !> where:
      !>
      !>    Q is a M-by-M orthogonal matrix, stored on exit in an implicit
      !>    form in the elements below the diagonal of the array A and in
      !>    the elements of the array T;
      !>
      !>    R is an upper-triangular N-by-N matrix, stored on exit in
      !>    the elements on and above the diagonal of the array A.
      !>
      !>    0 is a (M-N)-by-N zero matrix, and is not stored.
      !>
      !>

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 to be used in the blocked QR.
      !>          MB > 0.
      !>

  [in]

  NB

      !>          NB is INTEGER
      !>          The column block size to be used in the blocked QR.
      !>          N >= NB >= 1.
      !>

  [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 above the diagonal
      !>          of the array contain the N-by-N upper triangular matrix R;
      !>          the elements below the diagonal represent Q by the columns
      !>          of blocked V (see Further Details).
      !>

  [in]

  LDA

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

  [out]

  T

      !>          T is DOUBLE PRECISION array,
      !>          dimension (LDT, N * Number_of_row_blocks)
      !>          where Number_of_row_blocks = CEIL((M-N)/(MB-N))
      !>          The blocked upper triangular block reflectors stored in compact form
      !>          as a sequence of upper triangular blocks.
      !>          See Further Details below.
      !>

  [in]

  LDT

      !>          LDT is INTEGER
      !>          The leading dimension of the array T.  LDT >= NB.
      !>

  [out]

  WORK

      !>          (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
      !>          On exit, if INFO = 0, WORK(1) returns the minimal LWORK.
      !>

  [in]

  LWORK

      !>          LWORK is INTEGER
      !>          The dimension of the array WORK.
      !>          LWORK >= 1, if MIN(M,N) = 0, and LWORK >= NB*N, otherwise.
      !>
      !>          If LWORK = -1, then a workspace query is assumed; the routine
      !>          only calculates the minimal 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.

Further Details:

      !> Tall-Skinny QR (TSQR) performs QR by a sequence of orthogonal transformations,
      !> representing Q as a product of other orthogonal matrices
      !>   Q = Q(1) * Q(2) * . . . * Q(k)
      !> where each Q(i) zeros out subdiagonal entries of a block of MB rows of A:
      !>   Q(1) zeros out the subdiagonal entries of rows 1:MB of A
      !>   Q(2) zeros out the bottom MB-N rows of rows [1:N,MB+1:2*MB-N] of A
      !>   Q(3) zeros out the bottom MB-N rows of rows [1:N,2*MB-N+1:3*MB-2*N] of A
      !>   . . .
      !>
      !> Q(1) is computed by GEQRT, which represents Q(1) by Householder vectors
      !> stored under the diagonal of rows 1:MB of A, and by upper triangular
      !> block reflectors, stored in array T(1:LDT,1:N).
      !> For more information see Further Details in GEQRT.
      !>
      !> Q(i) for i>1 is computed by TPQRT, which represents Q(i) by Householder vectors
      !> stored in rows [(i-1)*(MB-N)+N+1:i*(MB-N)+N] of A, and by upper triangular
      !> block reflectors, stored in array T(1:LDT,(i-1)*N+1:i*N).
      !> The last Q(k) may use fewer rows.
      !> For more information see Further Details in TPQRT.
      !>
      !> For more details of the overall algorithm, see the description of
      !> Sequential TSQR in Section 2.2 of [1].
      !>
      !> [1] “Communication-Optimal Parallel and Sequential QR and LU Factorizations,”
      !>     J. Demmel, L. Grigori, M. Hoemmen, J. Langou,
      !>     SIAM J. Sci. Comput, vol. 34, no. 1, 2012
      !>