LQ APIs#

GELQ#

group gelq

Functions

template<typename T>
void gelq(integer *m, integer *n, T *a, integer *lda, T *t, integer *tsize, T *work, integer *lwork, integer *info)#

Computes LQ factorization of a real matrix.

Purpose:

 GELQ computes an LQ factorization of a real M-by-N matrix A:

   A = ( L 0) *  Q

 where:

 Q is a N-by-N orthogonal matrix;
 L is an lower-triangular M-by-M matrix;
 0 is a M-by-(N-M) zero matrix, if M < N.

Parameters:
  • M – [in]

    M is INTEGER

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

  • N – [in]

    N is INTEGER

    The number of columns of the matrix A. N >= 0.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the M-by-N matrix A.

    On exit, the elements on and below the diagonal of the array contain the M-by-min(M,N) lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the diagonal are used to store part of the data structure to represent - computes row and column scaling to reduce condition number of matrix

  • LDA/*! – [in]

    LDA is INTEGER

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

  • T – [out]

    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 – [in]

    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 – [out]

    (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 – [in]

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

GEMLQ#

group gemlq

Functions

template<typename T>
void gemlq(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *t, integer *tsize, T *c, integer *ldc, T *work, integer *lwork, integer *info)#

Overwrites general matrix with a form compatible with orthogonal matrix.

Purpose:

  GEMLQ overwrites the general real M-by-N matrix C with

                 SIDE = 'L'     SIDE = 'R'
 TRANS = 'N':      Q * C          C * Q
 TRANS = 'T':      Q**T * C       C * Q**T
 where Q is a real orthogonal matrix defined as the product
 of blocked elementary reflectors computed by short wide LQ
 factorization (GELQ)

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: apply Q or Q**T from the Left;

    = ‘R’: apply Q or Q**T from the Right.

  • TRANS – [in]

    TRANS is CHARACTER*1

    = ‘N’: No transpose, apply Q;

    = ‘T’: Transpose, apply Q**T.

  • M – [in]

    M is INTEGER

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

  • N – [in]

    N is INTEGER

    The number of columns of the matrix C. N >= 0.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q.

    If SIDE = ‘L’, M >= K >= 0;

    if SIDE = ‘R’, N >= K >= 0.

  • A – [in]

    A is REAL array, dimension

    (LDA,M) if SIDE = ‘L’,

    (LDA,N) if SIDE = ‘R’

    Part of the data structure to represent Q as returned by DGELQ.

    @para@[in] LDA LDA is INTEGER

    The leading dimension of the array A. LDA >= fla_max(1,K).

  • T – [in]

    T is REAL array, dimension (MAX(5,TSIZE)).

    Part of the data structure to represent Q as returned by SGELQ.

  • TSIZE – [in]

    TSIZE is INTEGER

    The dimension of the array T. TSIZE >= 5.

  • C – [inout]

    C is REAL array, dimension (LDC,N)

    On entry, the M-by-N matrix C.

    On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

  • LDC – [in]

    LDC is INTEGER

    The leading dimension of the array C. LDC >= fla_max(1,M).

  • WORK – [out] (workspace) REAL array, dimension (MAX(1,LWORK))

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK.

    If LWORK = -1, then a workspace query is assumed. The routine only calculates the size of the WORK array, returns this value as WORK(1), and no error message related to WORK is issued by XERBLA.

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

GELQF#

group gelqf

Functions

template<typename T>
void gelqf(integer *m, integer *n, T *a, integer *lda, T *tau, T *work, integer *lwork, integer *info)#

LQ factorization of a real m-by-n matrix a.

Purpose:

       LQ factorization of a real m-by-n matrix a
       The factorization has the form
           A = L * Q

Further Details

                     The matrix Q is represented as a product of elementary reflectors
                     Q = H(k) . . . H(2) H(1), where k = min(m,n).

                     Each H(i) has the form

                     H(i) = I - tau * V * V**T

                     where tau is a real scalar, and V is a real vector with V(1:i-1) = 0 and V(i) =
1; V(i+1:N) is stored on exit in A(i,i+1:N), and tau in tau(i).

Parameters:
  • m – [in]

    m is integer*

    The number of rows of the matrix a. m >= 0.

  • n – [in]

    n is integer*

    The number of columns of the matrix a. n >= 0.

  • a – [inout]

    a is float/double/COMPLEX/COMPLEX*16 array, dimension (lda,n)

    On entry, the m-by-n matrix.

    On exit, the elements on and below the diagonal of the array contain the m-by-min(m,n) lower trapezoidal matrix L (L is lower triangular if m <= n); the elements above the diagonal, with the array tau, represent the orthogonal matrix Q as a product of elementary reflectors (see Further Details).

  • lda – [in]

    lda is integer*

    The leading dimension of the matrix a, lda >= fla_max(1,m)

  • tau – [out]

    tau is float/double/COMPLEX/COMPLEX*16 array, dimension (min(m,n))

    The scalar factors of the elementary reflectors (see Further Details).

  • WORK – [out]

    WORK is COMPLEX array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK. LWORK >= fla_max(1,M). For optimum performance LWORK >= M*NB, where NB is the optimal blocksize.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

GELQ2#

group gelq2

Functions

template<typename T>
void gelq2(integer *m, integer *n, T *a, integer *lda, T *tau, T *work, integer *info)#

LQ factorization of a real m-by-n matrix a.

Purpose:

    LQ factorization of a real m-by-n matrix a
    The factorization has the form
    A = Q * R

Further Details

                  The matrix Q is represented as a product of elementary reflectors
                  Q = H(k) . . . H(2) H(1), where k = min(m,n).

                  Each H(i) has the form
                  H(i) = I - tau * V * V**T

                  where tau is a real scalar, and V is a real vector with V(1:i-1) = 0 and V(i) =
1; V(i+1:N) is stored on exit in A(i,i+1:N), and tau in tau(i).

Parameters:
  • m – [in]

    m is integer*

    The number of rows of the matrix a. m >= 0.

  • n – [in]

    n is integer*

    The number of columns of the matrix a. n >= 0.

  • a – [inout]

    a is float/double/COMPLEX/COMPLEX*16 array, dimension (lda,n)

    On entry, the m-by-n matrix.

    On exit, the elements on and below the diagonal of the array contain the m by min(m,n) lower trapezoidal matrix L (L is lower triangular if m <= n); the elements above the diagonal, with the array tau, represent the orthogonal matrix Q as a product of elementary reflectors (see Further Details).

  • lda – [in]

    lda is integer*

    The leading dimension of the matrix a, lda >= fla_max(1,m)

  • tau – [out]

    tau is float/double/COMPLEX/COMPLEX*16 array, dimension (min(m,n))

    The scalar factors of the elementary reflectors (see Further Details).

  • WORK – [out] WORK is COMPLEX array, dimension (M)

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

UNGLQ#

group unglq

Functions

template<typename T>
void unglq(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *lwork, integer *info)#

Form Q from LQ factorization.

Purpose:

       Generate an m-by-n complex matrix Q with orthonormal rows, which is defined as the first
       M rows of a product of K elementary reflectors of order N

       Q  =  H(k) . . . H(2) H(1)

       as returned by CGELQF.

Parameters:
  • m – [in]

    m is integer*

    The number of rows of the matrix Q. m >= 0.

  • n – [in]

    n is integer*

    The number of columns of the matrix Q. n >= m.

  • k – [in]

    k is integer*

    The number of elementary reflectors whose product defines the matrix Q. m >= k >= 0.

  • a – [inout]

    a is COMPLEX/COMPLEX*16 array, dimension (lda,n)

    On entry, the i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by CGELQF in the first k rows of its array argument a.

    On exit, the m-by-n matrix Q.

  • lda – [in]

    lda is integer*

    The first dimension of the array a. lda >= fla_max(1,m).

  • tau – [in]

    tau is COMPLEX/COMPLEX*16 array, dimension (k)

    tau(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGELQF.

  • WORK – [out]

    WORK is COMPLEX array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK. LWORK >= fla_max(1,M). For optimum performance LWORK >= M*NB, where NB is the optimal blocksize.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit;

    < 0: if INFO = -i, the i-th argument has an illegal value

ORGLQ#

group orglq

Functions

template<typename T>
void orglq(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *lwork, integer *info)#

Form Q from LQ factorization.

Purpose:

       Generate an m-by-n real matrix Q with orthonormal rows, which is defined as the first M
       rows of a product of K elementary reflectors of order N

       Q  =  H(k) . . . H(2) H(1)

       as returned by SGELQF.

Parameters:
  • m – [in]

    m is integer*

    The number of rows of the matrix Q. m >= 0.

  • n – [in]

    n is integer*

    The number of columns of the matrix Q. n >= m.

  • k – [in]

    k is integer*

    The number of elementary reflectors whose product defines the matrix Q. m >= k >= 0.

  • a – [inout]

    a is float/doublearray, dimension (lda,n)

    On entry, the i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGELQF in the first k rows of its array argument a. On exit, the m-by-n matrix Q.

  • lda – [in]

    lda is integer*

    The first dimension of the array a. lda >= fla_max(1,m).

  • tau – [in]

    tau is float/double array, dimension (k)

    tau(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGELQF.

  • WORK – [out]

    WORK is REAL array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK. LWORK >= fla_max(1,M). For optimum performance LWORK >= M*NB, where NB is the optimal blocksize.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument has an illegal value

ORGL2#

group orgl2

Functions

template<typename T>
void orgl2(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *info)#

ORGL2 generates an m by n real matrix Q with orthonormal rows.

Purpose:

 ORGL2 generates an m by n real matrix Q with orthonormal rows,
 which is defined as the first m rows of a product of k elementary
 reflectors of order n

       Q  =  H(k) . . . H(2) H(1)

 as   returned by GELQF.

Parameters:
  • M – [in]

    M is INTEGER

    The number of rows of the matrix Q. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix Q. N >= M.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q. M >= K >= 0.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGELQF in the first k rows of its array argument A.

    On exit, the m-by-n matrix Q.

  • LDA – [in]

    LDA is INTEGER

    The first dimension of the array A. LDA >= fla_max(1,M).

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGELQF.

  • WORK – [out] WORK is REAL array, dimension (M)

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument has an illegal value

template<typename T>
void ungl2(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *info)#

ORMLQ#

group ormlq

Functions

template<typename T>
void ormlq(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *lwork, integer *info)#

Apply Q or Q’ from LQ factorization.

Purpose:

       Apply Q or Q' from LQ factorization. Overwrite the general real m-by-n matrix c with

       side = 'L'  side = 'R'
       trans = 'N':   Q * C C * Q
       trans = 'T':   Q**T * C C * Q**T

       where Q is a real orthogonal matrix defined as the product of k elementary reflectors

       Q = H(k) . . . H(2) H(1)

       as returned by SGELQF. Q is of order M if side = 'L' and of order N if side = 'R'.

Parameters:
  • side – [in]

    side is char*

    = ‘L’: apply Q or Q**T from the Left;

    = ‘R’: apply Q or Q**T from the Right.

  • trans – [in]

    trans is char*

    = ‘N’: No transpose, apply Q;

    = ‘T’: Transpose, apply Q**T.

  • m – [in]

    m is integer*

    The number of rows of the matrix c. m >= 0.

  • n – [in]

    n is integer*

    The number of columns of the matrix c. n >= 0.

  • k – [in]

    k is integer*

    The number of elementary reflectors whose product defines the matrix Q.

    If side = ‘L’, m >= k >= 0;

    if side = ‘R’, n >= k >= 0.

  • a – [in]

    a is float/double/ array, dimension

    (lda,m) if side = ‘L’,

    (lda,n) if side = ‘R’

    The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGELQF in the first k rows of its array argument a.

  • lda – [in]

    lda is integer*

    The leading dimension of the array a. lda >= fla_max(1,k).

  • tau – [in]

    tau is float/double array, dimension (k)

    tau(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGELQF.

  • c – [inout]

    c is float/double array, dimension (ldc,n)

    On entry, the m-by-n matrix c.

    On exit, c is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

  • ldc – [in]

    ldc is integer*

    The leading dimension of the array c. ldc >= fla_max(1,m).

  • WORK – [out]

    WORK is REAL array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK.

    If SIDE = ‘L’, LWORK >= fla_max(1,N);

    if SIDE = ‘R’, LWORK >= fla_max(1,M).

    For good performance, LWORK should generally be larger.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

UNMLQ#

group unmlq

Functions

template<typename T>
void unmlq(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *lwork, integer *info)#

Apply Q or Q’ from LQ factorization.

Purpose:

       Apply Q or Q' from LQ factorization. Overwrite the general complex m-by-n matrix c with

       side = 'L'  side = 'R'
       trans = 'N':   Q * C C * Q
       trans = 'C':   Q**H * C C * Q**H

       where Q is a complex unitary matrix defined as the product of k elementary reflectors

       Q = H(k)**H . . . H(2)**H H(1)**H

       as returned by CGELQF. Q is of order M if side = 'L' and of order N if side = 'R'.

Parameters:
  • side – [in]

    side is char*

    = ‘L’: apply Q or Q**H from the Left;

    = ‘R’: apply Q or Q**H from the Right.

  • trans – [in]

    trans is char*

    = ‘N’: No transpose, apply Q;

    = ‘C’: Conjugate transpose, apply Q**H.

  • m – [in]

    m is integer*

    The number of rows of the matrix c. m >= 0.

  • n – [in]

    n is integer*

    The number of columns of the matrix c. n >= 0.

  • k – [in]

    k is integer*

    The number of elementary reflectors whose product defines the matrix Q.

    If side = ‘L’, m >= k >= 0;

    if side = ‘R’, n >= k >= 0.

  • a – [in]

    a is COMPLEX/COMPLEX*16 array, dimension

    (lda,m) if side = ‘L’,

    (lda,n) if side = ‘R’

    The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by CGELQF in the first k rows of its array argument a.

  • lda – [in]

    lda is integer*

    The leading dimension of the array a. lda >= fla_max(1,k).

  • tau – [in]

    tau is COMPLEX/COMPLEX*16 array, dimension (k)

    tau(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGELQF.

  • c – [inout]

    c is COMPLEX/COMPLEX*16 array, dimension (ldc,n)

    On entry, the m-by-n matrix c.

    On exit, c is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

  • ldc – [in]

    ldc is integer*

    The leading dimension of the array c. ldc >= fla_max(1,m).

  • WORK – [out]

    WORK is COMPLEX array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK.

    If SIDE = ‘L’, LWORK >= fla_max(1,N);

    if SIDE = ‘R’, LWORK >= fla_max(1,M).

    For good performance, LWORK should generally be larger.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

ORML2#

group orml2

Functions

template<typename T>
void orml2(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *info)#

Apply Q or Q’ from LQ factorization.

Purpose:

    Apply Q or Q' from LQ factorization. Overwrite the general real m-by-n matrix c with

    Q * C  if side = 'L' and trans = 'N', or

    Q**T* C  if side = 'L' and trans = 'T', or

    C * Q  if side = 'R' and trans = 'N', or

    C * Q**T if side = 'R' and trans = 'T',

    where Q is a real orthogonal matrix defined as the product of k elementary reflectors

    Q = H(k) . . . H(2) H(1)

    as returned by SGELQF. Q is of order m if side = 'L' and of order n

Parameters:
  • side – [in]

    side is char*

    = ‘L’: apply Q or Q**T from the Left;

    = ‘R’: apply Q or Q**T from the Right.

  • trans – [in]

    trans is char*

    = ‘N’: No transpose, apply Q;

    = ‘T’: Transpose, apply Q**T.

  • m – [in]

    m is integer*

    The number of rows of the matrix c. m >= 0.

  • n – [in]

    n is integer*

    The number of columns of the matrix c. n >= 0.

  • k – [in]

    k is integer*

    The number of elementary reflectors whose product defines the matrix Q.

    If side = ‘L’, m >= k >= 0;

    if side = ‘R’, n >= k >= 0.

  • a – [in]

    a is float/double array, dimension

    (lda,m) if side = ‘L’,

    (lda,n) if side = ‘R’

    The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGELQF in the first k rows of its array argument a.

    a is modified by the routine but restored on exit.

  • lda – [in]

    lda is integer*

    The leading dimension of the array a. lda >= fla_max(1,k).

  • tau – [in]

    tau is float/double array, dimension (k)

    tau(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGELQF.

  • c – [inout]

    c is float/double array, dimension (ldc,n)

    On entry, the m-by-n matrix c.

    On exit, c is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

  • ldc – [in]

    ldc is integer*

    The leading dimension of the array c. ldc >= fla_max(1,m).

  • WORK – [out]

    WORK is REAL array, dimension

    (N) if SIDE = ‘L’,

    (M) if SIDE = ‘R’

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

UNML2#

group unml2

Functions

template<typename T>
void unml2(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *info)#

Apply Q or Q’ from LQ factorization.

Purpose:

    Apply Q or Q' from LQ factorization. Overwrite the general complex m-by-n matrix c with

    Q * C  if side = 'L' and trans = 'N', or

    Q**H* C  if side = 'L' and trans = 'C', or

    C * Q  if side = 'R' and trans = 'N', or

    C * Q**H if side = 'R' and trans = 'C',

    where Q is a complex unitary matrix defined as the product of k elementary reflectors

    Q = H(k)**H . . . H(2)**H H(1)**H

    as returned by CGELQF. Q is of order m if side = 'L' and of order n

Parameters:
  • side – [in]

    side is char*

    = ‘L’: apply Q or Q**T from the Left;

    = ‘R’: apply Q or Q**T from the Right.

  • trans – [in]

    trans is char*

    = ‘N’: No transpose, apply Q;

    = ‘T’: Transpose, apply Q**T.

  • m – [in]

    m is integer*

    The number of rows of the matrix c. m >= 0.

  • n – [in]

    n is integer*

    The number of columns of the matrix c. n >= 0.

  • k – [in]

    k is integer*

    The number of elementary reflectors whose product defines the matrix Q.

    If side = ‘L’, m >= k >= 0;

    if side = ‘R’, n >= k >= 0.

  • a – [in]

    a is COMPLEX/COMPLEX*16 array, dimension

    (lda,m) if side = ‘L’,

    (lda,n) if side = ‘R’

    The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by CGELQF in the first k rows of its array argument a.

    a is modified by the routine but restored on exit.

  • lda – [in]

    lda is integer*

    The leading dimension of the array a. lda >= fla_max(1,k).

  • tau – [in]

    tau is COMPLEX/COMPLEX*16 array, dimension (k)

    tau(i) must contain the scalar factor of the elementary reflector H(i), as returned by CGELQF.

  • c – [inout]

    c is COMPLEX/COMPLEX*16 array, dimension (ldc,n)

    On entry, the m-by-n matrix c.

    On exit, c is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

  • ldc – [in]

    ldc is integer*

    The leading dimension of the array c. ldc >= fla_max(1,m).

  • WORK – [out]

    WORK is COMPLEX array, dimension

    (N) if SIDE = ‘L’,

    (M) if SIDE = ‘R’

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

GELQT#

group gelqt

Functions

template<typename T>
void gelqt(integer *m, integer *n, integer *mb, T *a, integer *lda, T *t, integer *ldt, T *work, integer *info)#

GELQT computes a blocked LQ factorization of a real M-by-N matrix A using the compact WY representation of Q.

Purpose:

 GELQT computes a blocked LQ factorization of a real M-by-N matrix A
 using the compact WY representation of Q.

Parameters:
  • M – [in]

    M is INTEGER

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

  • N – [in]

    N is INTEGER

    The number of columns of the matrix A. N >= 0.

  • MB – [in]

    MB is INTEGER

    The block size to be used in the blocked QR. MIN(M,N) >= MB >= 1.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the M-by-N matrix A.

    On exit, the elements on and below the diagonal of the array contain the M-by-MIN(M,N) lower trapezoidal matrix L (L is lower triangular if M <= N); the elements above the diagonal are the rows of V.

  • LDA – [in]

    LDA is INTEGER

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

  • T – [out]

    T is REAL array, dimension (LDT,MIN(M,N))

    The upper triangular block reflectors stored in compact form as a sequence of upper triangular blocks. See below for further details.

  • LDT – [in]

    LDT is INTEGER

    The leading dimension of the array T. LDT >= MB.

  • WORK – [out] WORK is REAL array, dimension (MB*N)

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

GELQT3#

group gelqt3

Functions

template<typename T>
void gelqt3(integer *m, integer *n, T *a, integer *lda, T *t, integer *ldt, integer *info)#

GELQT3 recursively computes a LQ factorization of a real M-by-N matrix A.

Purpose:

 GELQT3 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:
  • M – [in]

    M is INTEGER

    The number of rows of the matrix A. M =< N.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix A. N >= 0.

  • A – [inout]

    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.

  • LDA – [in]

    LDA is INTEGER

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

  • T – [out]

    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.

  • LDT – [in]

    LDT is INTEGER

    The leading dimension of the array T. LDT >= fla_max(1,N).

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

GEMLQR#

group gemlqr

Functions

template<typename T>
void gemlqt(char *side, char *trans, integer *m, integer *n, integer *k, integer *mb, T *v, integer *ldv, T *t, integer *ldt, T *c, integer *ldc, T *work, integer *info)#

GEMLQT overwrites the general real M-by-N matrix C.

Purpose:

 GEMLQT overwrites the general real M-by-N matrix C with

                SIDE = 'L'     SIDE = 'R'
 TRANS = 'N':      Q C            C Q
 TRANS = 'T':   Q**T C            C Q**T

 where Q is a real orthogonal matrix defined as the product of K
 elementary reflectors:

      Q = H(1) H(2) . . . H(K) = I - V T V**T

 generated using the compact WY representation as returned by DGELQT.

 Q is of order M if SIDE = 'L' and of order N  if SIDE = 'R'.

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: apply Q or Q**T from the Left;

    = ‘R’: apply Q or Q**T from the Right.

  • TRANS – [in]

    TRANS is CHARACTER*1

    = ‘N’: No transpose, apply Q;

    = ‘C’: Transpose, apply Q**T.

  • M – [in]

    M is INTEGER

    The number of rows of the matrix C. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix C. N >= 0.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q.

    If SIDE = ‘L’, M >= K >= 0;

    if SIDE = ‘R’, N >= K >= 0.

  • MB – [in]

    MB is INTEGER

    The block size used for the storage of T. K >= MB >= 1.

    This must be the same value of MB used to generate T in DGELQT.

  • V – [in]

    V is REAL array, dimension

    (LDV,M) if SIDE = ‘L’,

    (LDV,N) if SIDE = ‘R’

    The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by DGELQT in the first K rows of its array argument A.

  • LDV – [in]

    LDV is INTEGER

    The leading dimension of the array V. LDV >= fla_max(1,K).

  • T – [in]

    T is REAL array, dimension (LDT,K)

    The upper triangular factors of the block reflectors as returned by DGELQT, stored as a MB-by-K matrix.

  • LDT – [in]

    LDT is INTEGER

    The leading dimension of the array T. LDT >= MB.

  • C – [inout]

    C is REAL array, dimension (LDC,N)

    On entry, the M-by-N matrix C.

    On exit, C is overwritten by Q C, Q**T C, C Q**T or C Q.

  • LDC – [in]

    LDC is INTEGER

    The leading dimension of the array C. LDC >= fla_max(1,M).

  • WORK – [out]

    WORK is REAL array. The dimension of

    WORK is N*MB if SIDE = ‘L’, or M*MB if SIDE = ‘R’.

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

LAMSWLQ#

group lamswlq

Functions

template<typename T>
void lamswlq(char *side, char *trans, integer *m, integer *n, integer *k, integer *mb, integer *nb, T *a, integer *lda, T *t, integer *ldt, T *c, integer *ldc, T *work, integer *lwork, integer *info)#

LAMSWLQ overwrites the general real M-by-N matrix C.

Purpose:

 LAMSWLQ overwrites the general real M-by-N matrix C with

                 SIDE = 'L'     SIDE = 'R'
 TRANS = 'N':      Q * C          C * Q
 TRANS = 'T':      Q**T * C       C * Q**T
 where Q is a real orthogonal matrix defined as the product of blocked
 elementary reflectors computed by short wide LQ
 factorization (LASWLQ)

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: apply Q or Q**T from the Left;

    = ‘R’: apply Q or Q**T from the Right.

  • TRANS – [in]

    TRANS is CHARACTER*1

    = ‘N’: No transpose, apply Q;

    = ‘T’: Transpose, apply Q**T.

  • M – [in]

    M is INTEGER

    The number of rows of the matrix C. M >=0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix C. N >= M.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q. M >= K >= 0;

  • MB – [in]

    MB is INTEGER

    The row block size to be used in the blocked QR. M >= MB >= 1

  • NB – [in]

    NB is INTEGER

    The column block size to be used in the blocked QR. NB > M.

  • NB – [in]

    NB is INTEGER

    The block size to be used in the blocked QR. MB > M.

  • A – [in]

    A is REAL array, dimension

    (LDA,M) if SIDE = ‘L’,

    (LDA,N) if SIDE = ‘R’

    The i-th row must contain the vector which defines the blocked elementary reflector H(i), for i = 1,2,…,k, as returned by SLASWLQ in the first k rows of its array argument A.

  • LDA – [in]

    LDA is INTEGER

    The leading dimension of the array A.

    If SIDE = ‘L’, LDA >= fla_max(1,M);

    if SIDE = ‘R’, LDA >= fla_max(1,N).

  • T – [in]

    T is REAL array, dimension

    (M * Number of blocks(CEIL(N-K/NB-K)),

    The blocked upper triangular block reflectors stored in compact form as a sequence of upper triangular blocks. See below for further details.

  • LDT – [in]

    LDT is INTEGER

    The leading dimension of the array T. LDT >= MB.

  • C – [inout]

    C is REAL array, dimension (LDC,N)

    On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

  • LDC – [in]

    LDC is INTEGER

    The leading dimension of the array C. LDC >= fla_max(1,M).

  • WORK – [out] (workspace) REAL array, dimension (MAX(1,LWORK))

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK.

    If SIDE = ‘L’, LWORK >= fla_max(1,NB) * MB;

    if SIDE = ‘R’, LWORK >= fla_max(1,M) * MB.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

TPLQT#

group tplqt

Functions

template<typename T>
void tplqt(integer *m, integer *n, integer *l, integer *mb, T *a, integer *lda, T *b, integer *ldb, T *t, integer *ldt, T *work, integer *info)#

TPLQT computes a blocked LQ factorization of a real “triangular-pentagonal” matrix C.

Purpose:

 TPLQT computes a blocked LQ factorization of a real
 "triangular-pentagonal" matrix C, which is composed of a
 triangular block A and pentagonal block B, using the compact
 WY representation for Q.

Parameters:
  • M – [in]

    M is INTEGER

    The number of rows of the matrix B, and the order of the triangular matrix A.

    M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix B. N >= 0.

  • L – [in]

    L is INTEGER

    The number of rows of the lower trapezoidal part of B. MIN(M,N) >= L >= 0. See Further Details.

  • MB – [in]

    MB is INTEGER

    The block size to be used in the blocked QR. M >= MB >= 1.

  • A – [inout]

    A is REAL array, dimension (LDA,M)

    On entry, the lower triangular M-by-M matrix A. On exit, the elements on and below the diagonal of the array contain the lower triangular matrix L.

  • LDA – [in]

    LDA is INTEGER

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

  • B – [inout]

    B is REAL array, dimension (LDB,N)

    On entry, the pentagonal M-by-N matrix B. The first N-L columns are rectangular, and the last L columns are lower trapezoidal. On exit, B contains the pentagonal matrix V. See Further Details.

  • LDB – [in]

    LDB is INTEGER

    The leading dimension of the array B. LDB >= fla_max(1,M).

  • T – [out]

    T is REAL array, dimension (LDT,N)

    The lower triangular block reflectors stored in compact form as a sequence of upper triangular blocks. See Further Details.

  • LDT – [in]

    LDT is INTEGER

    The leading dimension of the array T. LDT >= MB.

  • WORK – [out] WORK is REAL array, dimension (MB*M)

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

TPLQT2#

group tplqt2

Functions

template<typename T>
void tplqt2(integer *m, integer *n, integer *l, T *a, integer *lda, T *b, integer *ldb, T *t, integer *ldt, integer *info)#

TPLQT2 computes a LQ factorization of a real or complex “triangular-pentagonal” matrix.

Purpose:

   TPLQT2 computes a LQ a factorization of a real "triangular-pentagonal"
   matrix C, which is composed of a triangular block A and pentagonal block B,
   using the compact WY representation for Q.

Parameters:
  • M – [in]

    M is INTEGER

    The total number of rows of the matrix B. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix B, and the order of the triangular matrix A. N >= 0.

  • L – [in]

    L is INTEGER

    The number of rows of the lower trapezoidal part of B. MIN(M,N) >= L >= 0. See Further Details.

  • A – [inout]

    A is REAL array, dimension (LDA,M)

    On entry, the lower triangular M-by-M matrix A.

    On exit, the elements on and below the diagonal of the array contain the lower triangular matrix L.

  • LDA – [in]

    LDA is INTEGER

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

  • B – [inout]

    B is REAL array, dimension (LDB,N)

    On entry, the pentagonal M-by-N matrix B. The first N-L columns are rectangular, and the last L columns are lower trapezoidal.

    On exit, B contains the pentagonal matrix V. See Further Details.

  • LDB – [in]

    LDB is INTEGER

    The leading dimension of the array B. LDB >= fla_max(1,M).

  • T – [out]

    T is REAL array, dimension (LDT,M)

    The N-by-N upper triangular factor T of the block reflector. See Further Details.

  • LDT – [in]

    LDT is INTEGER

    The leading dimension of the array T. LDT >= fla_max(1,M)

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

TPMLQT#

group tpmlqt

Functions

template<typename T>
void tpmlqt(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, integer *mb, T *v, integer *ldv, T *t, integer *ldt, T *a, integer *lda, T *b, integer *ldb, T *work, integer *info)#

TPMLQT applies a real orthogonal matrix Q obtained from a “triangular-pentagonal” real block reflector.

Purpose:

   TPMLQT applies a real orthogonal matrix Q obtained from a
   "triangular-pentagonal" real block reflector H to a general
   real matrix C, which consists of two blocks A and B.

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: apply Q or Q**T from the Left;

    = ‘R’: apply Q or Q**T from the Right.

  • TRANS – [in]

    TRANS is CHARACTER*1

    = ‘N’: No transpose, apply Q;

    = ‘T’: Transpose, apply Q**T.

  • M – [in]

    M is INTEGER

    The number of rows of the matrix B. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix B. N >= 0.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q.

  • L – [in]

    L is INTEGER

    The order of the trapezoidal part of V. K >= L >= 0. See Further Details.

  • MB – [in]

    MB is INTEGER

    The block size used for the storage of T. K >= MB >= 1. This must be the same value of MB used to generate T in DTPLQT.

  • V – [in]

    V is REAL array, dimension (LDV,K)

    The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by DTPLQT in B. See Further Details.

  • LDV – [in]

    LDV is INTEGER

    The leading dimension of the array V.

    If SIDE = ‘L’, LDV >= fla_max(1,M);

    if SIDE = ‘R’, LDV >= fla_max(1,N).

  • T – [in]

    T is REAL array, dimension (LDT,K)

    The upper triangular factors of the block reflectors as returned by DTPLQT, stored as a MB-by-K matrix.

  • LDT – [in]

    LDT is INTEGER

    The leading dimension of the array T. LDT >= MB.

  • A – [inout]

    A is REAL array, dimension (LDA,N) if SIDE = ‘L’ or (LDA,K) if SIDE = ‘R’

    On entry, the K-by-N or M-by-K matrix A.

    On exit, A is overwritten by the corresponding block of Q*C or Q**T*C or C*Q or C*Q**T. See Further Details.

  • LDA – [in]

    LDA is INTEGER

    The leading dimension of the array A.

    If SIDE = ‘L’, LDC >= fla_max(1,K);

    If SIDE = ‘R’, LDC >= fla_max(1,M).

  • B – [inout]

    B is REAL array, dimension (LDB,N)

    On entry, the M-by-N matrix B.

    On exit, B is overwritten by the corresponding block of Q*C or Q**T*C or C*Q or C*Q**T. See Further Details.

  • LDB – [in]

    LDB is INTEGER

    The leading dimension of the array B. LDB >= fla_max(1,M).

  • WORK – [out] WORK is REAL array. The dimension of WORK is N*MB if SIDE = ‘L’, or M*MB if SIDE = ‘R’.

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

GEQLF#

group geqlf

Functions

template<typename T>
void geqlf(integer *m, integer *n, T *a, integer *lda, T *tau, T *work, integer *lwork, integer *info)#

GEQLF computes a QL factorization of M-by-N matrix.

Purpose:

   GEQLF computes a QL factorization of M-by-N matrix A:
   A = Q * L.

Parameters:
  • M – [in]

    M is INTEGER

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

  • N – [in]

    N is INTEGER

    The number of columns of the matrix A. N >= 0.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the M-by-N matrix A.

    On exit, if m >= n, the lower triangle of the subarray A(m-n+1:m,1:n) contains the N-by-N lower triangular matrix L; if m <= n, the elements on and below the (n-m)-th superdiagonal contain the M-by-N lower trapezoidal matrix L; the remaining elements, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors (see Further Details).

  • LDA – [in]

    LDA is INTEGER

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

  • TAU – [out] TAU is array, dimension (min(M,N))

  • WORK – [out]

    WORK is COMPLEX array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK. LWORK >= fla_max(1,N). For optimum performance LWORK >= N*NB, where NB is the optimal blocksize.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

GERQ2#

group gerq2

Functions

template<typename T>
void gerq2(integer *m, integer *n, T *a, integer *lda, T *tau, T *work, integer *info)#

GERQ2 computes the RQ factorization of a general rectangular matrix using an unblocked algorithm.

Purpose:

   GERQ2 computes an RQ factorization of a real m by n matrix A:
   A = R * Q.

Parameters:
  • M – [in]

    M is INTEGER

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

  • N – [in]

    N is INTEGER

    The number of columns of the matrix A. N >= 0.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the m by n matrix A.

    On exit, if m <= n, the upper triangle of the subarray A(1:m,n-m+1:n) contains the m by m upper triangular matrix R; if m >= n, the elements on and above the (m-n)-th subdiagonal contain the m by n upper trapezoidal matrix R; the remaining elements, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors (see Further Details).

  • LDA – [in]

    LDA is INTEGER

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

  • TAU – [out]

    TAU is REAL array, dimension (min(M,N))

    The scalar factors of the elementary reflectors (see Further Details).

  • WORK – [out] WORK is REAL array, dimension (M)

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

UNGRQ#

group ungrq

Functions

template<typename T>
void orgrq(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *lwork, integer *info)#

ORGRQ generates an M-by-N real matrix Q with orthonormal rows.

Purpose:

    ORGRQ generates an M-by-N real matrix Q with orthonormal rows,
    which is defined as the last M rows of a product of K elementary
    reflectors of order N

          Q  =  H(1) H(2) . . . H(k)

    as returned by SGERQF.

Parameters:
  • M – [in]

    M is INTEGER

    The number of rows of the matrix Q. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix Q. N >= M.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q. M >= K >= 0.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the (m-k+i)-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGERQF in the last k rows of its array argument A.

    On exit, the M-by-N matrix Q.

  • LDA – [in]

    LDA is INTEGER

    The first dimension of the array A. LDA >= fla_max(1,M).

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGERQF.

  • WORK – [out]

    WORK is REAL array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK. LWORK >= fla_max(1,M). For optimum performance LWORK >= M*NB, where NB is the optimal blocksize.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument has an illegal value

template<typename T>
void ungrq(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *lwork, integer *info)#

UNMRQ#

group unmrq

Functions

template<typename T>
void ormrq(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *lwork, integer *info)#

ORMRQ overwrites the general real M-by-N matrix.

Purpose:

    ORMRQ overwrites the general real M-by-N matrix C with

                    SIDE = 'L'     SIDE = 'R'
    TRANS = 'N':      Q * C          C * Q
    TRANS = 'T':      Q**T * C       C * Q**T

    where Q is a real orthogonal matrix defined as the product of k
    elementary reflectors

          Q = H(1) H(2) . . . H(k)

    as returned by SGERQF. Q is of order M if SIDE = 'L' and of order N
    if SIDE = 'R'.

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: apply Q or Q**T from the Left;

    = ‘R’: apply Q or Q**T from the Right.

  • TRANS – [in]

    TRANS is CHARACTER*1

    = ‘N’: No transpose, apply Q;

    = ‘T’: Transpose, apply Q**T.

  • M – [in]

    M is INTEGER

    The number of rows of the matrix C. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix C. N >= 0.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q.

    If SIDE = ‘L’, M >= K >= 0;

    if SIDE = ‘R’, N >= K >= 0.

  • A – [in]

    A is REAL array, dimension

    (LDA,M) if SIDE = ‘L’,

    (LDA,N) if SIDE = ‘R’

    The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGERQF in the last k rows of its array argument A.

  • LDA – [in]

    LDA is INTEGER

    The leading dimension of the array A. LDA >= fla_max(1,K).

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGERQF.

  • C – [inout]

    C is REAL array, dimension (LDC,N)

    On entry, the M-by-N matrix C.

    On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

  • LDC – [in]

    LDC is INTEGER

    The leading dimension of the array C. LDC >= fla_max(1,M).

  • WORK – [out]

    WORK is REAL array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK.

    If SIDE = ‘L’, LWORK >= fla_max(1,N);

    if SIDE = ‘R’, LWORK >= fla_max(1,M).

    For good performance, LWORK should generally be larger.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

template<typename T>
void unmrq(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *lwork, integer *info)#

ORMR2#

group ormr2

Functions

template<typename T>
void ormr2(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *info)#

ORMR2 multiplies a general matrix by the orthogonal matrix from a RQ factorization determined by sgerqf.

Purpose:

   ORMR2 overwrites the general real m by n matrix C with

         Q * C  if SIDE = 'L' and TRANS = 'N', or

         Q**T* C  if SIDE = 'L' and TRANS = 'T', or

         C * Q  if SIDE = 'R' and TRANS = 'N', or

         C * Q**T if SIDE = 'R' and TRANS = 'T',

   where Q is a real orthogonal matrix defined as the product of k
   elementary reflectors

         Q = H(1) H(2) . . . H(k)

   as   returned by SGERQF. Q is of order m if SIDE = 'L' and of order n
   if SIDE = 'R'.

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: apply Q or Q**T from the Left

    = ‘R’: apply Q or Q**T from the Right

  • TRANS – [in]

    TRANS is CHARACTER*1

    = ‘N’: apply Q (No transpose)

    = ‘T’: apply Q’ (Transpose)

  • M – [in]

    M is INTEGER

    The number of rows of the matrix C. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix C. N >= 0.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q.

    If SIDE = ‘L’, M >= K >= 0;

    if SIDE = ‘R’, N >= K >= 0.

  • A – [in]

    A is REAL array, dimension

    (LDA,M) if SIDE = ‘L’,

    (LDA,N) if SIDE = ‘R’

    The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGERQF in the last k rows of its array argument A. A is modified by the routine but restored on exit.

  • LDA – [in]

    LDA is INTEGER

    The leading dimension of the array A. LDA >= fla_max(1,K).

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGERQF.

  • C – [inout]

    C is REAL array, dimension (LDC,N)

    On entry, the m by n matrix C.

    On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

  • LDC – [in]

    LDC is INTEGER

    The leading dimension of the array C. LDC >= fla_max(1,M).

  • WORK – [out]

    WORK is REAL array, dimension

    (N) if SIDE = ‘L’,

    (M) if SIDE = ‘R’

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

template<typename T>
void unmr2(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *info)#

ORGR2#

group orgr2

Functions

template<typename T>
void orgr2(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *info)#

ORGR2 generates all or part of the orthogonal matrix Q from an RQ factorization determined by sgerqf.

Purpose:

   ORGR2 generates an m by n real matrix Q with orthonormal rows,
   which is defined as the last m rows of a product of k elementary
   reflectors of order n

         Q  =  H(1) H(2) . . . H(k)

   as   returned by SGERQF.

Parameters:
  • M – [in]

    M is INTEGER

    The number of rows of the matrix Q. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix Q. N >= M.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q. M >= K >= 0.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the (m-k+i)-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGERQF in the last k rows of its array argument A.

    On exit, the m by n matrix Q.

  • LDA – [in]

    LDA is INTEGER

    The first dimension of the array A. LDA >= fla_max(1,M).

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGERQF.

  • WORK – [out] WORK is REAL array, dimension (M)

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument has an illegal value

template<typename T>
void ungr2(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *info)#

GEQL2#

group geql2

Functions

template<typename T>
void geql2(integer *m, integer *n, T *a, integer *lda, T *tau, T *work, integer *info)#

GEQL2 computes the QL factorization of a general rectangular matrix using an unblocked algorithm.

Purpose:

   GEQL2 computes a QL factorization of a real m by n matrix A:
   A = Q * L.

Parameters:
  • M – [in]

    M is INTEGER

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

  • N – [in]

    N is INTEGER

    The number of columns of the matrix A. N >= 0.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the m by n matrix A.

    On exit, if m >= n, the lower triangle of the subarray A(m-n+1:m,1:n) contains the n by n lower triangular matrix L; if m <= n, the elements on and below the (n-m)-th superdiagonal contain the m by n lower trapezoidal matrix L; the remaining elements, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors (see Further Details).

  • LDA – [in]

    LDA is INTEGER

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

  • TAU – [out]

    TAU is REAL array, dimension (min(M,N))

    The scalar factors of the elementary reflectors (see Further Details).

  • WORK – [out] WORK is REAL array, dimension (N)

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

ORGQL#

group orgql

Functions

template<typename T>
void orgql(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *lwork, integer *info)#

ORGQL generates an M-by-N real matrix Q with orthonormal columns.

Purpose:

   ORGQL generates an M-by-N real matrix Q with orthonormal columns,
   which is defined as the last N columns of a product of K elementary
   reflectors of order M
         Q  =  H(k) . . . H(2) H(1)
   as returned by GEQLF.

Parameters:
  • M – [in]

    M is INTEGER

    The number of rows of the matrix Q. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix Q. M >= N >= 0.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the (n-k+i)-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGEQLF in the last k columns of its array argument A.

    On exit, the M-by-N matrix Q.

  • LDA – [in]

    LDA is INTEGER

    The first dimension of the array A. LDA >= fla_max(1,M).

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by GEQLF.

  • WORK – [out]

    WORK is REAL array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK. LWORK >= fla_max(1,N). For optimum performance LWORK >= N*NB, where NB is the optimal blocksize.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument has an illegal value

template<typename T>
void ungql(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *lwork, integer *info)#

ORMQL#

group ormql

Functions

template<typename T>
void ormql(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *lwork, integer *info)#

ORMQL overwrites the general real M-by-N matrix.

Purpose:

    ORMQL overwrites the general real M-by-N matrix C with

                    SIDE = 'L'     SIDE = 'R'
    TRANS = 'N':      Q * C          C * Q
    TRANS = 'T':      Q**T * C       C * Q**T

    where Q is a real orthogonal matrix defined as the product of k
    elementary reflectors

          Q = H(k) . . . H(2) H(1)

    as returned by SGEQLF. Q is of order M if SIDE = 'L' and of order N
    if SIDE = 'R'.

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: apply Q or Q**T from the Left;

    = ‘R’: apply Q or Q**T from the Right.

  • TRANS – [in]

    TRANS is CHARACTER*1

    = ‘N’: No transpose, apply Q;

    = ‘T’: Transpose, apply Q**T.

  • M – [in]

    M is INTEGER

    The number of rows of the matrix C. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix C. N >= 0.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q.

    If SIDE = ‘L’, M >= K >= 0;

    if SIDE = ‘R’, N >= K >= 0.

  • A – [in]

    A is REAL array, dimension (LDA,K)

    The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGEQLF in the last k columns of its array argument A.

  • LDA – [in]

    LDA is INTEGER

    The leading dimension of the array A.

    If SIDE = ‘L’, LDA >= fla_max(1,M);

    if SIDE = ‘R’, LDA >= fla_max(1,N).

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQLF.

  • C – [inout]

    C is REAL array, dimension (LDC,N)

    On entry, the M-by-N matrix C.

    On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

  • LDC – [in]

    LDC is INTEGER

    The leading dimension of the array C. LDC >= fla_max(1,M).

  • WORK – [out]

    WORK is REAL array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK.

    If SIDE = ‘L’, LWORK >= fla_max(1,N);

    if SIDE = ‘R’, LWORK >= fla_max(1,M).

    For good performance, LWORK should generally be larger.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

template<typename T>
void unmql(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *lwork, integer *info)#

ORG2L#

group org2l

Functions

template<typename T>
void org2l(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *info)#

ORG2L generates all or part of the orthogonal matrix Q from a QL factorization determined by sgeqlf.

Purpose:

   ORG2L generates an m by n real matrix Q with orthonormal columns,
   which is defined as the last n columns of a product of k elementary
   reflectors of order m

         Q  =  H(k) . . . H(2) H(1)

   as   returned by GEQLF.

Parameters:
  • M – [in]

    M is INTEGER

    The number of rows of the matrix Q. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix Q. M >= N >= 0.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the (n-k+i)-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGEQLF in the last k columns of its array argument A.

    On exit, the m by n matrix Q.

  • LDA – [in]

    LDA is INTEGER

    The first dimension of the array A. LDA >= fla_max(1,M).

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQLF.

  • WORK – [out] WORK is REAL array, dimension (N)

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument has an illegal value

template<typename T>
void ung2l(integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *work, integer *info)#

ORM2L#

group orm2l

Functions

template<typename T>
void orm2l(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *info)#

ORM2L multiplies a general matrix by the orthogonal matrix from a QL factorization determined by sgeqlf.

Purpose:

   ORM2L overwrites the general real m by n matrix C with

         Q * C  if SIDE = 'L' and TRANS = 'N', or

         Q**T * C  if SIDE = 'L' and TRANS = 'T', or

         C * Q  if SIDE = 'R' and TRANS = 'N', or

         C * Q**T if SIDE = 'R' and TRANS = 'T',

   where Q is a real orthogonal matrix defined as the product of k
   elementary reflectors

         Q = H(k) . . . H(2) H(1)

   as   returned by SGEQLF. Q is of order m if SIDE = 'L' and of order n
   if SIDE = 'R'.

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: apply Q or Q**T from the Left

    = ‘R’: apply Q or Q**T from the Right

  • TRANS – [in]

    TRANS is CHARACTER*1

    = ‘N’: apply Q (No transpose)

    = ‘T’: apply Q**T (Transpose)

  • M – [in]

    M is INTEGER

    The number of rows of the matrix C. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix C. N >= 0.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q.

    If SIDE = ‘L’, M >= K >= 0;

    if SIDE = ‘R’, N >= K >= 0.

  • A – [in]

    A is REAL array, dimension (LDA,K)

    The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by SGEQLF in the last k columns of its array argument A. A is modified by the routine but restored on exit.

  • LDA – [in]

    LDA is INTEGER

    The leading dimension of the array A.

    If SIDE = ‘L’, LDA >= fla_max(1,M);

    if SIDE = ‘R’, LDA >= fla_max(1,N).

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SGEQLF.

  • C – [inout]

    C is REAL array, dimension (LDC,N)

    On entry, the m by n matrix C.

    On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

  • LDC – [in]

    LDC is INTEGER

    The leading dimension of the array C. LDC >= fla_max(1,M).

  • WORK – [out]

    WORK is REAL array, dimension

    (N) if SIDE = ‘L’,

    (M) if SIDE = ‘R’

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

template<typename T>
void unm2l(char *side, char *trans, integer *m, integer *n, integer *k, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *info)#

GGRQF#

group ggrqf

Functions

template<typename T>
void ggrqf(integer *m, integer *p, integer *n, T *a, integer *lda, T *taua, T *b, integer *ldb, T *taub, T *work, integer *lwork, integer *info)#

GGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B.

Purpose:

    GGRQF computes a generalized RQ factorization of an M-by-N matrix A
    and a P-by-N matrix B:
                A = R*Q,        B = Z*T*Q,

    where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal
    matrix, and R and T assume one of the forms:
    if M <= N,  R = ( 0  R12) M,   or if M > N,  R = ( R11) M-N,
                     N-M  M                           ( R21) N
                                                         N
    where R12 or R21 is upper triangular, and
    if P >= N,  T = ( T11) N  ,   or if P < N,  T = ( T11  T12) P,
                    (  0 ) P-N                         P   N-P
                       N
    where T11 is upper triangular.
    In particular, if B is square and nonsingular, the GRQ factorization
    of A and B implicitly gives the RQ factorization of A*inv(B):
                 A*inv(B) = (R*inv(T))*Z**T
    where inv(B) denotes the inverse of the matrix B, and Z**T denotes the
    transpose of the matrix Z.

Parameters:
  • M – [in]

    M is INTEGER

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

  • P – [in]

    P is INTEGER

    The number of rows of the matrix B. P >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrices A and B. N >= 0.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the M-by-N matrix A.

    On exit, if M <= N, the upper triangle of the subarray A(1:M,N-M+1:N) contains the M-by-M upper triangular matrix R; if M > N, the elements on and above the (M-N)-th subdiagonal contain the M-by-N upper trapezoidal matrix R; the remaining elements, with the array TAUA, represent the orthogonal matrix Q as a product of elementary reflectors (see Further Details).

  • LDA – [in]

    LDA is INTEGER

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

  • TAUA – [out]

    TAUA is REAL array, dimension (min(M,N))

    The scalar factors of the elementary reflectors which represent the orthogonal matrix Q (see Further Details).

  • B – [inout]

    B is REAL array, dimension (LDB,N)

    On entry, the P-by-N matrix B.

    On exit, the elements on and above the diagonal of the array contain the min(P,N)-by-N upper trapezoidal matrix T (T is upper triangular if P >= N); the elements below the diagonal, with the array TAUB, represent the orthogonal matrix Z as a product of elementary reflectors (see Further Details).

  • LDB – [in]

    LDB is INTEGER

    The leading dimension of the array B. LDB >= fla_max(1,P).

  • TAUB – [out]

    TAUB is REAL array, dimension (min(P,N))

    The scalar factors of the elementary reflectors which represent the orthogonal matrix Z (see Further Details).

  • WORK – [out]

    WORK is REAL array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK. LWORK >= fla_max(1,N,M,P).

    For optimum performance LWORK >= fla_max(N,M,P)*max(NB1,NB2,NB3), where NB1 is the optimal blocksize for the RQ factorization of an M-by-N matrix, NB2 is the optimal blocksize for the QR factorization of a P-by-N matrix, and NB3 is the optimal blocksize for a call of SORMRQ.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INF0= -i, the i-th argument had an illegal value.

TZRZF#

group tzrzf

Functions

template<typename T>
void tzrzf(integer *m, integer *n, T *a, integer *lda, T *tau, T *work, integer *lwork, integer *info)#

TZRZF reduces the M-by-N ( M<=N) real upper trapezoidal matrix A

to upper triangular form by means of orthogonal transformations.

Purpose:

   TZRZF reduces the M-by-N ( M<=N) real upper trapezoidal matrix A
   to upper triangular form by means of orthogonal transformations.

   The upper trapezoidal matrix A is factored as

      A = ( R  0) * Z,

   where Z is an N-by-N orthogonal matrix and R is an M-by-M upper
   triangular matrix.

Parameters:
  • M – [in]

    M is INTEGER

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

  • N – [in]

    N is INTEGER

    The number of columns of the matrix A. N >= M.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the leading M-by-N upper trapezoidal part of the array A must contain the matrix to be factorized. On exit, the leading M-by-M upper triangular part of A contains the upper triangular matrix R, and elements M+1 to N of the first M rows of A, with the array TAU, represent the orthogonal matrix Z as a product of M elementary reflectors.

  • LDA – [in]

    LDA is INTEGER

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

  • TAU – [out]

    TAU is REAL array, dimension (M)

    The scalar factors of the elementary reflectors.

  • WORK – [out]

    WORK is REAL array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK. LWORK >= fla_max(1,M). For optimum performance LWORK >= M*NB, where NB is the optimal blocksize.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

LATRZ#

group latrz

Functions

template<typename T>
void latrz(integer *m, integer *n, integer *l, T *a, integer *lda, T *tau, T *work)#

LATRZ factors an upper trapezoidal matrix by means of orthogonal transformations.

Purpose:

 LATRZ factors the M-by-(M+L) real upper trapezoidal matrix
 [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as (R  0) * Z, by means
 of orthogonal transformations.  Z is an (M+L)-by-(M+L) orthogonal
 matrix and, R and A1 are M-by-M upper triangular matrices.

Parameters:
  • M – [in]

    M is INTEGER

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

  • N – [in]

    N is INTEGER

    The number of columns of the matrix A. N >= 0.

  • L – [in]

    L is INTEGER

    The number of columns of the matrix A containing the meaningful part of the Householder vectors. N-M >= L >= 0.

  • A – [inout]

    A is REAL array, dimension (LDA,N)

    On entry, the leading M-by-N upper trapezoidal part of the array A must contain the matrix to be factorized. On exit, the leading M-by-M upper triangular part of A contains the upper triangular matrix R, and elements N-L+1 to N of the first M rows of A, with the array TAU, represent the orthogonal matrix Z as a product of M elementary reflectors.

  • LDA – [in]

    LDA is INTEGER

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

  • TAU – [out]

    TAU is REAL array, dimension (M)

    The scalar factors of the elementary reflectors.

  • WORK – [out] WORK is REAL array, dimension (M)

LARZ#

group larz

Functions

template<typename T>
void larz(char *side, integer *m, integer *n, integer *l, T *v, integer *incv, T *tau, T *c, integer *ldc, T *work)#

LARZ applies an elementary reflector (as returned by stzrzf) to a general matrix.

Purpose:

 LARZ applies a real elementary reflector H to a real M-by-N
 matrix C, from either the left or the right. H is represented in the
 form

       H = I - tau * v * v**T

 where tau is a real scalar and v is a real vector.

 If tau = 0, then H is taken to be the unit matrix.


 H is a product of k elementary reflectors as   returned by STZRZF.

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: form H * C

    = ‘R’: form C * H

  • M – [in]

    M is INTEGER

    The number of rows of the matrix C.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix C.

  • L – [in]

    L is INTEGER

    The number of entries of the vector V containing the meaningful part of the Householder vectors.

    If SIDE = ‘L’, M >= L >= 0, if SIDE = ‘R’, N >= L >= 0.

  • V – [in]

    V is REAL array, dimension (1+(L-1)*abs(INCV))

    The vector v in the representation of H as returned by STZRZF. V is not used if TAU = 0.

  • INCV – [in]

    INCV is INTEGER

    The increment between elements of v. INCV <> 0.

  • TAU – [in]

    TAU is REAL

    The value tau in the representation of H.

  • C – [inout]

    C is REAL array, dimension (LDC,N)

    On entry, the M-by-N matrix C. On exit, C is overwritten by the matrix H * C if SIDE = ‘L’, or C * H if SIDE = ‘R’.

  • LDC – [in]

    LDC is INTEGER

    The leading dimension of the array C. LDC >= fla_max(1,M).

  • WORK – [out]

    WORK is REAL array, dimension

    (N) if SIDE = ‘L’

    or (M) if SIDE = ‘R’

LARZB#

group larzb

Functions

template<typename T>
void larzb(char *side, char *trans, char *direct, char *storev, integer *m, integer *n, integer *k, integer *l, T *v, integer *ldv, T *t, integer *ldt, T *c, integer *ldc, T *work, integer *ldwork)#

LARZB applies a block reflector or its transpose to a general matrix.

Purpose:

 LARZB applies a real block reflector H or its transpose H**T to
 a real distributed M-by-N  C from the left or the right.

 Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: apply H or H**T from the Left

    = ‘R’: apply H or H**T from the Right

  • TRANS – [in]

    TRANS is CHARACTER*1

    = ‘N’: apply H (No transpose)

    = ‘C’: apply H**T (Transpose)

  • DIRECT – [in]

    DIRECT is CHARACTER*1

    Indicates how H is formed from a product of elementary reflectors

    = ‘F’: H = H(1) H(2) … H(k) (Forward, not supported yet)

    = ‘B’: H = H(k) … H(2) H(1) (Backward)

  • STOREV – [in]

    STOREV is CHARACTER*1

    Indicates how the vectors which define the elementary reflectors are stored:

    = ‘C’: Columnwise (not supported yet)

    = ‘R’: Rowwise

  • M – [in]

    M is INTEGER

    The number of rows of the matrix C.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix C.

  • K – [in]

    K is INTEGER

    The order of the matrix T (= the number of elementary reflectors whose product defines the block reflector).

  • L – [in]

    L is INTEGER

    The number of columns of the matrix V containing the meaningful part of the Householder reflectors.

    If SIDE = ‘L’, M >= L >= 0, if SIDE = ‘R’, N >= L >= 0.

  • V – [in]

    V is REAL array, dimension (LDV,NV).

    If STOREV = ‘C’, NV = K; if STOREV = ‘R’, NV = L.

  • LDV – [in]

    LDV is INTEGER

    The leading dimension of the array V.

    If STOREV = ‘C’, LDV >= L; if STOREV = ‘R’, LDV >= K.

  • T – [in]

    T is REAL array, dimension (LDT,K)

    The triangular K-by-K matrix T in the representation of the block reflector.

  • LDT – [in]

    LDT is INTEGER

    The leading dimension of the array T. LDT >= K.

  • C – [inout]

    C is REAL array, dimension (LDC,N)

    On entry, the M-by-N matrix C. On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T.

  • LDC – [in]

    LDC is INTEGER

    The leading dimension of the array C. LDC >= fla_max(1,M).

  • WORK – [out] WORK is REAL array, dimension (LDWORK,K)

  • LDWORK – [in]

    LDWORK is INTEGER

    The leading dimension of the array WORK.

    If SIDE = ‘L’, LDWORK >= fla_max(1,N);

    if SIDE = ‘R’, LDWORK >= fla_max(1,M).

LARZT#

group larzt

Functions

template<typename T>
void larzt(char *direct, char *storev, integer *n, integer *k, T *v, integer *ldv, T *tau, T *t, integer *ldt)#

LARZT forms the triangular factor T of a block reflector H = I - vtvH.

Purpose:

 LARZT forms the triangular factor T of a real block reflector
 H of order > n, which is defined as a product of k elementary
 reflectors.

 If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;

 If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.

 If STOREV = 'C', the vector which defines the elementary reflector
 H(i) is stored in the i-th column of the array V, and

    H  =  I - V * T * V**T

 If STOREV = 'R', the vector which defines the elementary reflector
 H(i) is stored in the i-th row of the array V, and

    H  =  I - V**T * T * V

 Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

Parameters:
  • DIRECT – [in]

    DIRECT is CHARACTER*1

    Specifies the order in which the elementary reflectors are multiplied to form the block reflector:

    = ‘F’: H = H(1) H(2) … H(k) (Forward, not supported yet)

    = ‘B’: H = H(k) … H(2) H(1) (Backward)

  • STOREV – [in]

    STOREV is CHARACTER*1

    Specifies how the vectors which define the elementary reflectors are stored (see also Further Details):

    = ‘C’: columnwise (not supported yet)

    = ‘R’: rowwise

  • N – [in]

    N is INTEGER

    The order of the block reflector H. N >= 0.

  • K – [in]

    K is INTEGER

    The order of the triangular factor T (= the number of elementary reflectors). K >= 1.

  • V – [inout]

    V is REAL array, dimension

    (LDV,K) if STOREV = ‘C’

    (LDV,N) if STOREV = ‘R’

    The matrix V. See further details.

  • LDV – [in]

    LDV is INTEGER

    The leading dimension of the array V. If STOREV = ‘C’, LDV >= fla_max(1,N); if STOREV = ‘R’, LDV >= K.

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i).

  • T – [out]

    T is REAL array, dimension (LDT,K)

    The k by k triangular factor T of the block reflector. If DIRECT = ‘F’, T is upper triangular; if DIRECT = ‘B’, T is lower triangular. The rest of the array is not used.

  • LDT – [in]

    LDT is INTEGER

    The leading dimension of the array T. LDT >= K.

ORMZR#

group ormzr

Functions

template<typename T>
void ormrz(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *lwork, integer *info)#

ORMRZ overwrites the general real M-by-N matrix.

Purpose:

    ORMRZ overwrites the general real M-by-N matrix C with

                    SIDE = 'L'     SIDE = 'R'
    TRANS = 'N':      Q * C          C * Q
    TRANS = 'T':      Q**T * C       C * Q**T

    where Q is a real orthogonal matrix defined as the product of k
    elementary reflectors

          Q = H(1) H(2) . . . H(k)

    as returned by STZRZF. Q is of order M if SIDE = 'L' and of order N
    if SIDE = 'R'.

Arguments:#

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: apply Q or Q**T from the Left;

    = ‘R’: apply Q or Q**T from the Right.

  • TRANS – [in]

    TRANS is CHARACTER*1

    = ‘N’: No transpose, apply Q;

    = ‘T’: Transpose, apply Q**T.

  • M – [in]

    M is INTEGER

    The number of rows of the matrix C. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix C. N >= 0.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q.

    If SIDE = ‘L’, M >= K >= 0;

    if SIDE = ‘R’, N >= K >= 0.

  • L – [in]

    L is INTEGER

    The number of columns of the matrix A containing the meaningful part of the Householder reflectors.

    If SIDE = ‘L’, M >= L >= 0, if SIDE = ‘R’, N >= L >= 0.

  • A – [in]

    A is REAL array, dimension

    (LDA,M) if SIDE = ‘L’,

    (LDA,N) if SIDE = ‘R’

    The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by STZRZF in the last k rows of its array argument A. A is modified by the routine but restored on exit.

  • LDA – [in]

    LDA is INTEGER

    The leading dimension of the array A. LDA >= fla_max(1,K).

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by STZRZF.

  • C – [inout]

    C is REAL array, dimension (LDC,N)

    On entry, the M-by-N matrix C.

    On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

  • LDC – [in]

    LDC is INTEGER

    The leading dimension of the array C. LDC >= fla_max(1,M).

  • WORK – [out]

    WORK is REAL array, dimension (MAX(1,LWORK))

    On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

  • LWORK – [in]

    LWORK is INTEGER

    The dimension of the array WORK.

    If SIDE = ‘L’, LWORK >= fla_max(1,N);

    if SIDE = ‘R’, LWORK >= fla_max(1,M).

    For good performance, LWORK should generally be larger.

    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 – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

template<typename T>
void unmrz(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *lwork, integer *info)#

ORMR3#

group ormr3

Functions

template<typename T>
void ormr3(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *info)#

ORMR3 multiplies a general matrix by the orthogonal matrix from a RZ factorization determined by stzrzf.

Purpose:

   ORMR3 overwrites the general real m by n matrix C with

         Q * C  if SIDE = 'L' and TRANS = 'N', or

         Q**T* C  if SIDE = 'L' and TRANS = 'C', or

         C * Q  if SIDE = 'R' and TRANS = 'N', or

         C * Q**T if SIDE = 'R' and TRANS = 'C',

   where Q is a real orthogonal matrix defined as the product of k
   elementary reflectors

         Q = H(1) H(2) . . . H(k)

   as   returned by STZRZF. Q is of order m if SIDE = 'L' and of order n
   if SIDE = 'R'.

Parameters:
  • SIDE – [in]

    SIDE is CHARACTER*1

    = ‘L’: apply Q or Q**T from the Left

    = ‘R’: apply Q or Q**T from the Right

  • TRANS – [in]

    TRANS is CHARACTER*1

    = ‘N’: apply Q (No transpose)

    = ‘T’: apply Q**T (Transpose)

  • M – [in]

    M is INTEGER

    The number of rows of the matrix C. M >= 0.

  • N – [in]

    N is INTEGER

    The number of columns of the matrix C. N >= 0.

  • K – [in]

    K is INTEGER

    The number of elementary reflectors whose product defines the matrix Q.

    If SIDE = ‘L’, M >= K >= 0;

    if SIDE = ‘R’, N >= K >= 0.

  • L – [in]

    L is INTEGER

    The number of columns of the matrix A containing the meaningful part of the Householder reflectors.

    If SIDE = ‘L’, M >= L >= 0, if SIDE = ‘R’, N >= L >= 0.

  • A – [in]

    A is REAL array, dimension

    (LDA,M) if SIDE = ‘L’,

    (LDA,N) if SIDE = ‘R’

    The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,…,k, as returned by STZRZF in the last k rows of its array argument A.

    A is modified by the routine but restored on exit.

  • LDA – [in]

    LDA is INTEGER

    The leading dimension of the array A. LDA >= fla_max(1,K).

  • TAU – [in]

    TAU is REAL array, dimension (K)

    TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by STZRZF.

  • C – [inout]

    C is REAL array, dimension (LDC,N)

    On entry, the m-by-n matrix C.

    On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

  • LDC – [in]

    LDC is INTEGER

    The leading dimension of the array C. LDC >= fla_max(1,M).

  • WORK – [out]

    WORK is REAL array, dimension

    (N) if SIDE = ‘L’,

    (M) if SIDE = ‘R’

  • INFO – [out]

    INFO is INTEGER

    = 0: successful exit

    < 0: if INFO = -i, the i-th argument had an illegal value

template<typename T>
void unmr3(char *side, char *trans, integer *m, integer *n, integer *k, integer *l, T *a, integer *lda, T *tau, T *c, integer *ldc, T *work, integer *info)#