Provided by: liblapack-doc_3.12.0-3build1_all bug

NAME

       geqr - geqr: QR factor, flexible

SYNOPSIS

   Functions
       subroutine cgeqr (m, n, a, lda, t, tsize, work, lwork, info)
           CGEQR
       subroutine dgeqr (m, n, a, lda, t, tsize, work, lwork, info)
           DGEQR
       subroutine sgeqr (m, n, a, lda, t, tsize, work, lwork, info)
           SGEQR
       subroutine zgeqr (m, n, a, lda, t, tsize, work, lwork, info)
           ZGEQR

Detailed Description

Function Documentation

   subroutine cgeqr (integer m, integer n, complex, dimension( lda, * ) a, integer lda, complex,
       dimension( * ) t, integer tsize, complex, dimension( * ) work, integer lwork, integer
       info)
       CGEQR

       Purpose:

            CGEQR computes a QR factorization of a complex M-by-N matrix A:

               A = Q * ( R ),
                       ( 0 )

            where:

               Q is a M-by-M orthogonal matrix;
               R is an upper-triangular N-by-N matrix;
               0 is a (M-N)-by-N zero matrix, if M > N.

       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.  N >= 0.

           A

                     A is COMPLEX 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 min(M,N)-by-N upper trapezoidal matrix R
                     (R is upper triangular if M >= N);
                     the elements below the diagonal are used to store part of the
                     data structure to represent Q.

           LDA

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

           T

                     T is COMPLEX 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.

           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).

           WORK

                     (workspace) COMPLEX 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.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     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).

           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 QR factorization algorithm they wish. The triangular
            (trapezoidal) R has to be stored in the upper 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
                                      CLATSQR or CGEQRT

             Depending on the matrix dimensions M and N, and row and column
             block sizes MB and NB returned by ILAENV, CGEQR will use either
             CLATSQR (if the matrix is tall-and-skinny) or CGEQRT to compute
             the QR factorization.

   subroutine dgeqr (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)
       DGEQR

       Purpose:

            DGEQR computes a QR factorization of a real M-by-N matrix A:

               A = Q * ( R ),
                       ( 0 )

            where:

               Q is a M-by-M orthogonal matrix;
               R is an upper-triangular N-by-N matrix;
               0 is a (M-N)-by-N zero matrix, if M > N.

       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.  N >= 0.

           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 min(M,N)-by-N upper trapezoidal matrix R
                     (R is upper triangular if M >= N);
                     the elements below the diagonal are used to store part of the
                     data structure to represent Q.

           LDA

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

           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.

           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).

           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.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     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).

           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 QR factorization algorithm they wish. The triangular
            (trapezoidal) R has to be stored in the upper 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
                                      DLATSQR or DGEQRT

             Depending on the matrix dimensions M and N, and row and column
             block sizes MB and NB returned by ILAENV, DGEQR will use either
             DLATSQR (if the matrix is tall-and-skinny) or DGEQRT to compute
             the QR factorization.

   subroutine sgeqr (integer m, integer n, real, dimension( lda, * ) a, integer lda, real,
       dimension( * ) t, integer tsize, real, dimension( * ) work, integer lwork, integer info)
       SGEQR

       Purpose:

            SGEQR computes a QR factorization of a real M-by-N matrix A:

               A = Q * ( R ),
                       ( 0 )

            where:

               Q is a M-by-M orthogonal matrix;
               R is an upper-triangular N-by-N matrix;
               0 is a (M-N)-by-N zero matrix, if M > N.

       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.  N >= 0.

           A

                     A is REAL 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 min(M,N)-by-N upper trapezoidal matrix R
                     (R is upper triangular if M >= N);
                     the elements below the diagonal are used to store part of the
                     data structure to represent Q.

           LDA

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

           T

                     T is REAL 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.

           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).

           WORK

                     (workspace) REAL 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.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     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).

           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 QR factorization algorithm they wish. The triangular
            (trapezoidal) R has to be stored in the upper 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
                                      SLATSQR or SGEQRT

             Depending on the matrix dimensions M and N, and row and column
             block sizes MB and NB returned by ILAENV, SGEQR will use either
             SLATSQR (if the matrix is tall-and-skinny) or SGEQRT to compute
             the QR factorization.

   subroutine zgeqr (integer m, integer n, complex*16, dimension( lda, * ) a, integer lda,
       complex*16, dimension( * ) t, integer tsize, complex*16, dimension( * ) work, integer
       lwork, integer info)
       ZGEQR

       Purpose:

            ZGEQR computes a QR factorization of a complex M-by-N matrix A:

               A = Q * ( R ),
                       ( 0 )

            where:

               Q is a M-by-M orthogonal matrix;
               R is an upper-triangular N-by-N matrix;
               0 is a (M-N)-by-N zero matrix, if M > N.

       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.  N >= 0.

           A

                     A is COMPLEX*16 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 min(M,N)-by-N upper trapezoidal matrix R
                     (R is upper triangular if M >= N);
                     the elements below the diagonal are used to store part of the
                     data structure to represent Q.

           LDA

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

           T

                     T is COMPLEX*16 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.

           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).

           WORK

                     (workspace) COMPLEX*16 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.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     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).

           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 QR factorization algorithm they wish. The triangular
            (trapezoidal) R has to be stored in the upper 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
                                      ZLATSQR or ZGEQRT

             Depending on the matrix dimensions M and N, and row and column
             block sizes MB and NB returned by ILAENV, ZGEQR will use either
             ZLATSQR (if the matrix is tall-and-skinny) or ZGEQRT to compute
             the QR factorization.

Author

       Generated automatically by Doxygen for LAPACK from the source code.