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 matrixLDA/*! – [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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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
-
template<typename T>
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>
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>
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 RightTRANS – [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>
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>
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
-
template<typename T>
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>
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>
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>
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 RightTRANS – [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>
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.
-
template<typename T>
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
-
template<typename T>
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)
-
template<typename T>
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 * HM – [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’
-
template<typename T>
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 RightTRANS – [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).
-
template<typename T>
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.
-
template<typename T>
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>
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 RightTRANS – [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>