Loading...
Searching...
No Matches

## cungtsqr_row()

subroutine cungtsqr_row | ( | integer | m,
|  | integer | n,
|  | integer | mb,
|  | integer | nb,
|  | complex, dimension( lda, * ) | a,
|  | integer | lda,
|  | complex, dimension( ldt, * ) | t,
|  | integer | ldt,
|  | complex, dimension( * ) | work,
|  | integer | lwork,
|  | integer | info )

CUNGTSQR_ROW

Download CUNGTSQR_ROW + dependencies [TGZ] [ZIP] [TXT]

Purpose:

      !>
      !> CUNGTSQR_ROW generates an M-by-N complex matrix Q_out with
      !> orthonormal columns from the output of CLATSQR. These N orthonormal
      !> columns are the first N columns of a product of complex unitary
      !> matrices Q(k)_in of order M, which are returned by CLATSQR in
      !> a special format.
      !>
      !>      Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ).
      !>
      !> The input matrices Q(k)_in are stored in row and column blocks in A.
      !> See the documentation of CLATSQR for more details on the format of
      !> Q(k)_in, where each Q(k)_in is represented by block Householder
      !> transformations. This routine calls an auxiliary routine CLARFB_GETT,
      !> where the computation is performed on each individual block. The
      !> algorithm first sweeps NB-sized column blocks from the right to left
      !> starting in the bottom row block and continues to the top row block
      !> (hence _ROW in the routine name). This sweep is in reverse order of
      !> the order in which CLATSQR generates the output blocks.
      !>

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 used by CLATSQR to return
      !>          arrays A and T. MB > N.
      !>          (Note that if MB > M, then M is used instead of MB
      !>          as the row block size).
      !>

  [in]

  NB

      !>          NB is INTEGER
      !>          The column block size used by CLATSQR to return
      !>          arrays A and T. NB >= 1.
      !>          (Note that if NB > N, then N is used instead of NB
      !>          as the column block size).
      !>

  [in,out]

  A

      !>          A is COMPLEX array, dimension (LDA,N)
      !>
      !>          On entry:
      !>
      !>             The elements on and above the diagonal are not used as
      !>             input. The elements below the diagonal represent the unit
      !>             lower-trapezoidal blocked matrix V computed by CLATSQR
      !>             that defines the input matrices Q_in(k) (ones on the
      !>             diagonal are not stored). See CLATSQR for more details.
      !>
      !>          On exit:
      !>
      !>             The array A contains an M-by-N orthonormal matrix Q_out,
      !>             i.e the columns of A are orthogonal unit vectors.
      !>

  [in]

  LDA

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

  [in]

  T

      !>          T is COMPLEX array,
      !>          dimension (LDT, N * NIRB)
      !>          where NIRB = Number_of_input_row_blocks
      !>                     = MAX( 1, CEIL((M-N)/(MB-N)) )
      !>          Let NICB = Number_of_input_col_blocks
      !>                   = CEIL(N/NB)
      !>
      !>          The upper-triangular block reflectors used to define the
      !>          input matrices Q_in(k), k=(1:NIRB*NICB). The block
      !>          reflectors are stored in compact form in NIRB block
      !>          reflector sequences. Each of the NIRB block reflector
      !>          sequences is stored in a larger NB-by-N column block of T
      !>          and consists of NICB smaller NB-by-NB upper-triangular
      !>          column blocks. See CLATSQR for more details on the format
      !>          of T.
      !>

  [in]

  LDT

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

  [out]

  WORK

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

  [in]

  LWORK

      !>          LWORK is INTEGER
      !>          The dimension of the array WORK.
      !>          LWORK >= NBLOCAL * MAX(NBLOCAL,(N-NBLOCAL)),
      !>          where NBLOCAL=MIN(NB,N).
      !>          If LWORK = -1, then a workspace query is assumed.
      !>          The routine only calculates the optimal 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.

Contributors:

      !>
      !> November 2020, Igor Kozachenko,
      !>                Computer Science Division,
      !>                University of California, Berkeley
      !>
      !>