getsqrhrt(3)

NAME
getsqrhrt - getsqrhrt: tall-skinny QR factor, with Householder reconstruction

SYNOPSIS

  Functions
subroutine cgetsqrhrt (m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)
CGETSQRHRT
subroutine dgetsqrhrt (m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)
DGETSQRHRT
subroutine sgetsqrhrt (m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)
SGETSQRHRT
subroutine zgetsqrhrt (m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)
ZGETSQRHRT

Detailed Description

Function Documentation

  subroutine cgetsqrhrt (integer m, integer n, integer mb1, integer nb1, integer nb2, complex, dimension( lda, * ) a, integer lda, complex, dimension( ldt, * ) t, integer ldt, complex, dimension( * ) work, integer lwork, integer info)

CGETSQRHRT

Purpose:

    !>
    !> CGETSQRHRT computes a NB2-sized column blocked QR-factorization
    !> of a complex M-by-N matrix A with M >= N,
    !>
    !>    A = Q * R.
    !>
    !> The routine uses internally a NB1-sized column blocked and MB1-sized
    !> row blocked TSQR-factorization and perfors the reconstruction
    !> of the Householder vectors from the TSQR output. The routine also
    !> converts the R_tsqr factor from the TSQR-factorization output into
    !> the R factor that corresponds to the Householder QR-factorization,
    !>
    !>    A = Q_tsqr * R_tsqr = Q * R.
    !>
    !> The output Q and R factors are stored in the same format as in CGEQRT
    !> (Q is in blocked compact WY-representation). See the documentation
    !> of CGEQRT for more details on the format.
    !>

Parameters
    M

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

    N

    !>          N is INTEGER
    !>          The number of columns of the matrix A. M >= N >= 0.
    !>

    MB1

    !>          MB1 is INTEGER
    !>          The row block size to be used in the blocked TSQR.
    !>          MB1 > N.
    !>

    NB1

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

    NB2

    !>          NB2 is INTEGER
    !>          The block size to be used in the blocked QR that is
    !>          output. NB2 >= 1.
    !>

    A

    !>          A is COMPLEX*16 array, dimension (LDA,N)
    !>
    !>          On entry: an M-by-N matrix A.
    !>
    !>          On exit:
    !>           a) the elements on and above the diagonal
    !>              of the array contain the N-by-N upper-triangular
    !>              matrix R corresponding to the Householder QR;
    !>           b) the elements below the diagonal represent Q by
    !>              the columns of blocked V (compact WY-representation).
    !>

    LDA

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

    T

    !>          T is COMPLEX array, dimension (LDT,N))
    !>          The upper triangular block reflectors stored in compact form
    !>          as a sequence of upper triangular blocks.
    !>

    LDT

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

    WORK

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

    LWORK

    !>          LWORK is INTEGER
    !>          The dimension of the array WORK.
    !>          If MIN(M,N) = 0, LWORK >= 1, else
    !>          LWORK >= MAX( 1, LWT + LW1, MAX( LWT+N*N+LW2, LWT+N*N+N ) ),
    !>          where
    !>             NUM_ALL_ROW_BLOCKS = CEIL((M-N)/(MB1-N)),
    !>             NB1LOCAL = MIN(NB1,N).
    !>             LWT = NUM_ALL_ROW_BLOCKS * N * NB1LOCAL,
    !>             LW1 = NB1LOCAL * N,
    !>             LW2 = NB1LOCAL * MAX( NB1LOCAL, ( N - NB1LOCAL ) ).
    !>
    !>          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.
    !>

    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
    !>
    !>

Definition at line 180 of file cgetsqrhrt.f.

  subroutine dgetsqrhrt (integer m, integer n, integer mb1, integer nb1, integer nb2, double precision, dimension( lda, * ) a, integer lda, double precision, dimension( ldt, * ) t, integer ldt, double precision, dimension( * ) work, integer lwork, integer info)

DGETSQRHRT

Purpose:

    !>
    !> DGETSQRHRT computes a NB2-sized column blocked QR-factorization
    !> of a real M-by-N matrix A with M >= N,
    !>
    !>    A = Q * R.
    !>
    !> The routine uses internally a NB1-sized column blocked and MB1-sized
    !> row blocked TSQR-factorization and perfors the reconstruction
    !> of the Householder vectors from the TSQR output. The routine also
    !> converts the R_tsqr factor from the TSQR-factorization output into
    !> the R factor that corresponds to the Householder QR-factorization,
    !>
    !>    A = Q_tsqr * R_tsqr = Q * R.
    !>
    !> The output Q and R factors are stored in the same format as in DGEQRT
    !> (Q is in blocked compact WY-representation). See the documentation
    !> of DGEQRT for more details on the format.
    !>

Parameters
    M

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

    N

    !>          N is INTEGER
    !>          The number of columns of the matrix A. M >= N >= 0.
    !>

    MB1

    !>          MB1 is INTEGER
    !>          The row block size to be used in the blocked TSQR.
    !>          MB1 > N.
    !>

    NB1

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

    NB2

    !>          NB2 is INTEGER
    !>          The block size to be used in the blocked QR that is
    !>          output. NB2 >= 1.
    !>

    A

    !>          A is DOUBLE PRECISION array, dimension (LDA,N)
    !>
    !>          On entry: an M-by-N matrix A.
    !>
    !>          On exit:
    !>           a) the elements on and above the diagonal
    !>              of the array contain the N-by-N upper-triangular
    !>              matrix R corresponding to the Householder QR;
    !>           b) the elements below the diagonal represent Q by
    !>              the columns of blocked V (compact WY-representation).
    !>

    LDA

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

    T

    !>          T is DOUBLE PRECISION array, dimension (LDT,N))
    !>          The upper triangular block reflectors stored in compact form
    !>          as a sequence of upper triangular blocks.
    !>

    LDT

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

    WORK

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

    LWORK

    !>          LWORK is INTEGER
    !>          The dimension of the array WORK.
    !>          If MIN(M,N) = 0, LWORK >= 1, else
    !>          LWORK >= MAX( 1, LWT + LW1, MAX( LWT+N*N+LW2, LWT+N*N+N ) ),
    !>          where
    !>             NUM_ALL_ROW_BLOCKS = CEIL((M-N)/(MB1-N)),
    !>             NB1LOCAL = MIN(NB1,N).
    !>             LWT = NUM_ALL_ROW_BLOCKS * N * NB1LOCAL,
    !>             LW1 = NB1LOCAL * N,
    !>             LW2 = NB1LOCAL * MAX( NB1LOCAL, ( N - NB1LOCAL ) ).
    !>
    !>          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.
    !>

    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
    !>
    !>

Definition at line 180 of file dgetsqrhrt.f.

  subroutine sgetsqrhrt (integer m, integer n, integer mb1, integer nb1, integer nb2, real, dimension( lda, * ) a, integer lda, real, dimension( ldt, * ) t, integer ldt, real, dimension( * ) work, integer lwork, integer info)

SGETSQRHRT

Purpose:

    !>
    !> SGETSQRHRT computes a NB2-sized column blocked QR-factorization
    !> of a complex M-by-N matrix A with M >= N,
    !>
    !>    A = Q * R.
    !>
    !> The routine uses internally a NB1-sized column blocked and MB1-sized
    !> row blocked TSQR-factorization and perfors the reconstruction
    !> of the Householder vectors from the TSQR output. The routine also
    !> converts the R_tsqr factor from the TSQR-factorization output into
    !> the R factor that corresponds to the Householder QR-factorization,
    !>
    !>    A = Q_tsqr * R_tsqr = Q * R.
    !>
    !> The output Q and R factors are stored in the same format as in SGEQRT
    !> (Q is in blocked compact WY-representation). See the documentation
    !> of SGEQRT for more details on the format.
    !>

Parameters
    M

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

    N

    !>          N is INTEGER
    !>          The number of columns of the matrix A. M >= N >= 0.
    !>

    MB1

    !>          MB1 is INTEGER
    !>          The row block size to be used in the blocked TSQR.
    !>          MB1 > N.
    !>

    NB1

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

    NB2

    !>          NB2 is INTEGER
    !>          The block size to be used in the blocked QR that is
    !>          output. NB2 >= 1.
    !>

    A

    !>          A is REAL array, dimension (LDA,N)
    !>
    !>          On entry: an M-by-N matrix A.
    !>
    !>          On exit:
    !>           a) the elements on and above the diagonal
    !>              of the array contain the N-by-N upper-triangular
    !>              matrix R corresponding to the Householder QR;
    !>           b) the elements below the diagonal represent Q by
    !>              the columns of blocked V (compact WY-representation).
    !>

    LDA

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

    T

    !>          T is REAL array, dimension (LDT,N))
    !>          The upper triangular block reflectors stored in compact form
    !>          as a sequence of upper triangular blocks.
    !>

    LDT

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

    WORK

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

    LWORK

    !>          LWORK is INTEGER
    !>          The dimension of the array WORK.
    !>          If MIN(M,N) = 0, LWORK >= 1, else
    !>          LWORK >= MAX( 1, LWT + LW1, MAX( LWT+N*N+LW2, LWT+N*N+N ) ),
    !>          where
    !>             NUM_ALL_ROW_BLOCKS = CEIL((M-N)/(MB1-N)),
    !>             NB1LOCAL = MIN(NB1,N).
    !>             LWT = NUM_ALL_ROW_BLOCKS * N * NB1LOCAL,
    !>             LW1 = NB1LOCAL * N,
    !>             LW2 = NB1LOCAL * MAX( NB1LOCAL, ( N - NB1LOCAL ) ).
    !>
    !>          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.
    !>

    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
    !>
    !>

Definition at line 180 of file sgetsqrhrt.f.

  subroutine zgetsqrhrt (integer m, integer n, integer mb1, integer nb1, integer nb2, complex*16, dimension( lda, * ) a, integer lda, complex*16, dimension( ldt, * ) t, integer ldt, complex*16, dimension( * ) work, integer lwork, integer info)

ZGETSQRHRT

Purpose:

    !>
    !> ZGETSQRHRT computes a NB2-sized column blocked QR-factorization
    !> of a complex M-by-N matrix A with M >= N,
    !>
    !>    A = Q * R.
    !>
    !> The routine uses internally a NB1-sized column blocked and MB1-sized
    !> row blocked TSQR-factorization and perfors the reconstruction
    !> of the Householder vectors from the TSQR output. The routine also
    !> converts the R_tsqr factor from the TSQR-factorization output into
    !> the R factor that corresponds to the Householder QR-factorization,
    !>
    !>    A = Q_tsqr * R_tsqr = Q * R.
    !>
    !> The output Q and R factors are stored in the same format as in ZGEQRT
    !> (Q is in blocked compact WY-representation). See the documentation
    !> of ZGEQRT for more details on the format.
    !>

Parameters
    M

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

    N

    !>          N is INTEGER
    !>          The number of columns of the matrix A. M >= N >= 0.
    !>

    MB1

    !>          MB1 is INTEGER
    !>          The row block size to be used in the blocked TSQR.
    !>          MB1 > N.
    !>

    NB1

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

    NB2

    !>          NB2 is INTEGER
    !>          The block size to be used in the blocked QR that is
    !>          output. NB2 >= 1.
    !>

    A

    !>          A is COMPLEX*16 array, dimension (LDA,N)
    !>
    !>          On entry: an M-by-N matrix A.
    !>
    !>          On exit:
    !>           a) the elements on and above the diagonal
    !>              of the array contain the N-by-N upper-triangular
    !>              matrix R corresponding to the Householder QR;
    !>           b) the elements below the diagonal represent Q by
    !>              the columns of blocked V (compact WY-representation).
    !>

    LDA

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

    T

    !>          T is COMPLEX*16 array, dimension (LDT,N))
    !>          The upper triangular block reflectors stored in compact form
    !>          as a sequence of upper triangular blocks.
    !>

    LDT

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

    WORK

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

    LWORK

    !>          LWORK is INTEGER
    !>          The dimension of the array WORK.
    !>          If MIN(M,N) = 0, LWORK >= 1, else
    !>          LWORK >= MAX( 1, LWT + LW1, MAX( LWT+N*N+LW2, LWT+N*N+N ) ),
    !>          where
    !>             NUM_ALL_ROW_BLOCKS = CEIL((M-N)/(MB1-N)),
    !>             NB1LOCAL = MIN(NB1,N).
    !>             LWT = NUM_ALL_ROW_BLOCKS * N * NB1LOCAL,
    !>             LW1 = NB1LOCAL * N,
    !>             LW2 = NB1LOCAL * MAX( NB1LOCAL, ( N - NB1LOCAL ) ).
    !>
    !>          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.
    !>

    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
    !>
    !>

Definition at line 180 of file zgetsqrhrt.f.

Author

Generated automatically by Doxygen for LAPACK from the source code.