larft_lvl2#
Functions
-
void slarft_lvl2(const char *direct, const char *storev, const INT n, const INT k, const f32 *restrict V, const INT ldv, const f32 *restrict tau, f32 *restrict T, const INT ldt)#
SLARFT_LVL2 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(0) H(1) … H(k-1) and T is upper triangular;If
direct='B', H = H(k-1) … H(1) H(0) and T is lower triangular.If
storev='C', the vector which defines the elementary reflector H(i) is stored in columniof the arrayV, andH = I - V * T * V**T
If
storev='R', the vector which defines the elementary reflector H(i) is stored in rowiof the arrayV, andH = I - V**T * T * V
If
directorstorev='T', see Further Details for the shape of T- Further Details:
The shape of the matrix V and the storage of the vectors which define the H(i) is best illustrated by the following example with n = 5 and k = 3. The elements equal to 1 are not stored.
DIRECT = 'F' and STOREV = 'C': DIRECT = 'F' and STOREV = 'R': V = ( 1 ) V = ( 1 v0 v0 v0 v0 ) ( v0 1 ) ( 1 v1 v1 v1 ) ( v0 v1 1 ) ( 1 v2 v2 ) ( v0 v1 v2 ) ( v0 v1 v2 ) DIRECT = 'B' and STOREV = 'C': DIRECT = 'B' and STOREV = 'R': V = ( v0 v1 v2 ) V = ( v0 v0 1 ) ( v0 v1 v2 ) ( v1 v1 v1 1 ) ( 1 v1 v2 ) ( v2 v2 v2 v2 1 ) ( 1 v2 ) ( 1 )In addition, the shape of T is determined by these same flags as in the below table. ‘U’ denotes upper triangular ‘L’ denotes lower triangular ‘X’ denotes no current implementation We also provide the logical variable that represents the case in the code if it is implemented
|-----------------------------------------------------------| | | DIRECT = 'F' | DIRECT = 'B' | DIRECT = 'T' | |--------------+--------------+--------------+--------------| | STOREV = 'C' | U (QR) | L (QL) | X | | STOREV = 'R' | U (LQ) | L (RQ) | U (RQT) | | STOREV = 'T' | L (LQT) | X | X | |-----------------------------------------------------------|
Finally, the relationship between the (conjugate) transposed T matrices are as follows: (Note that T_{FC} denotes the T associated with calling this routine with DIRECT = ‘F’ and STOREV = ‘C’)
T_{TR} = (T_{BR})**H T_{FT} = (T_{FR})**H
Parameters
indirectSpecifies the order in which the elementary reflectors are multiplied to form the block reflector:
'F': H = H(0) H(1) … H(k-1) (Forward)'B': H = H(k-1) … H(1) H(0) (Backward)'T'(withstorev='R'): H = H(k-1) … H(1) H(0) (backward) but we return the T matrix that is already (conjugate) transposed
instorevSpecifies how the vectors which define the elementary reflectors are stored (see also Further Details):
'C': column-wise'R': row-wise'T': (Withdirect='F') Row-wise, but we return the T matrix that is already (conjugate) transposed.
innThe order of the block reflector H.
n>=0.inkThe order of the triangular factor T (= the number of elementary reflectors).
k>=1.inVArray of dimension (
ldv,k) ifstorev='C', (ldv,n) ifstorev='R'. The matrix V. See further details.inldvThe leading dimension of the array
V. Ifstorev='C',ldv>=max(1,n); ifstorev='R',ldv>=k.intauArray of dimension (
k).tau[i]must contain the scalar factor of the elementary reflector H(i).outTArray of dimension (
ldt,k). The k by k triangular factor T of the block reflector. Ifdirect='F', T is upper triangular; ifdirect='B', T is lower triangular. The rest of the array is not used.inldtThe leading dimension of the array
T.ldt>=k.
void slarft_lvl2(
const char* direct,
const char* storev,
const INT n,
const INT k,
const f32* restrict V,
const INT ldv,
const f32* restrict tau,
f32* restrict T,
const INT ldt
);
Functions
-
void dlarft_lvl2(const char *direct, const char *storev, const INT n, const INT k, const f64 *restrict V, const INT ldv, const f64 *restrict tau, f64 *restrict T, const INT ldt)#
DLARFT_LVL2 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(0) H(1) … H(k-1) and T is upper triangular;If
direct='B', H = H(k-1) … H(1) H(0) and T is lower triangular.If
storev='C', the vector which defines the elementary reflector H(i) is stored in columniof the arrayV, andH = I - V * T * V**T
If
storev='R', the vector which defines the elementary reflector H(i) is stored in rowiof the arrayV, andH = I - V**T * T * V
If
directorstorev='T', see Further Details for the shape of T- Further Details:
The shape of the matrix V and the storage of the vectors which define the H(i) is best illustrated by the following example with n = 5 and k = 3. The elements equal to 1 are not stored.
DIRECT = 'F' and STOREV = 'C': DIRECT = 'F' and STOREV = 'R': V = ( 1 ) V = ( 1 v0 v0 v0 v0 ) ( v0 1 ) ( 1 v1 v1 v1 ) ( v0 v1 1 ) ( 1 v2 v2 ) ( v0 v1 v2 ) ( v0 v1 v2 ) DIRECT = 'B' and STOREV = 'C': DIRECT = 'B' and STOREV = 'R': V = ( v0 v1 v2 ) V = ( v0 v0 1 ) ( v0 v1 v2 ) ( v1 v1 v1 1 ) ( 1 v1 v2 ) ( v2 v2 v2 v2 1 ) ( 1 v2 ) ( 1 )In addition, the shape of T is determined by these same flags as in the below table. ‘U’ denotes upper triangular ‘L’ denotes lower triangular ‘X’ denotes no current implementation We also provide the logical variable that represents the case in the code if it is implemented
|-----------------------------------------------------------| | | DIRECT = 'F' | DIRECT = 'B' | DIRECT = 'T' | |--------------+--------------+--------------+--------------| | STOREV = 'C' | U (QR) | L (QL) | X | | STOREV = 'R' | U (LQ) | L (RQ) | U (RQT) | | STOREV = 'T' | L (LQT) | X | X | |-----------------------------------------------------------|
Finally, the relationship between the (conjugate) transposed T matrices are as follows: (Note that T_{FC} denotes the T associated with calling this routine with DIRECT = ‘F’ and STOREV = ‘C’)
T_{TR} = (T_{BR})**H T_{FT} = (T_{FR})**H
Parameters
indirectSpecifies the order in which the elementary reflectors are multiplied to form the block reflector:
'F': H = H(0) H(1) … H(k-1) (Forward)'B': H = H(k-1) … H(1) H(0) (Backward)'T'(withstorev='R'): H = H(k-1) … H(1) H(0) (backward) but we return the T matrix that is already (conjugate) transposed
instorevSpecifies how the vectors which define the elementary reflectors are stored (see also Further Details):
'C': column-wise'R': row-wise'T': (Withdirect='F') Row-wise, but we return the T matrix that is already (conjugate) transposed.
innThe order of the block reflector H.
n>=0.inkThe order of the triangular factor T (= the number of elementary reflectors).
k>=1.inVArray of dimension (
ldv,k) ifstorev='C', (ldv,n) ifstorev='R'. The matrix V. See further details.inldvThe leading dimension of the array
V. Ifstorev='C',ldv>=max(1,n); ifstorev='R',ldv>=k.intauArray of dimension (
k).tau[i]must contain the scalar factor of the elementary reflector H(i).outTArray of dimension (
ldt,k). The k by k triangular factor T of the block reflector. Ifdirect='F', T is upper triangular; ifdirect='B', T is lower triangular. The rest of the array is not used.inldtThe leading dimension of the array
T.ldt>=k.
void dlarft_lvl2(
const char* direct,
const char* storev,
const INT n,
const INT k,
const f64* restrict V,
const INT ldv,
const f64* restrict tau,
f64* restrict T,
const INT ldt
);
Functions
-
void clarft_lvl2(const char *direct, const char *storev, const INT n, const INT k, const c64 *restrict V, const INT ldv, const c64 *restrict tau, c64 *restrict T, const INT ldt)#
CLARFT_LVL2 forms the triangular factor T of a complex block reflector H of order n, which is defined as a product of k elementary reflectors.
If
direct='F', H = H(0) H(1) … H(k-1) and T is upper triangular;If
direct='B', H = H(k-1) … H(1) H(0) and T is lower triangular.If
storev='C', the vector which defines the elementary reflector H(i) is stored in columniof the arrayV, andH = I - V * T * V**H
If
storev='R', the vector which defines the elementary reflector H(i) is stored in rowiof the arrayV, andH = I - V**H * T * V
If
directorstorev='T', see Further Details for the shape of T- Further Details:
The shape of the matrix V and the storage of the vectors which define the H(i) is best illustrated by the following example with n = 5 and k = 3. The elements equal to 1 are not stored.
DIRECT = 'F' and STOREV = 'C': DIRECT = 'F' and STOREV = 'R': V = ( 1 ) V = ( 1 v0 v0 v0 v0 ) ( v0 1 ) ( 1 v1 v1 v1 ) ( v0 v1 1 ) ( 1 v2 v2 ) ( v0 v1 v2 ) ( v0 v1 v2 ) DIRECT = 'B' and STOREV = 'C': DIRECT = 'B' and STOREV = 'R': V = ( v0 v1 v2 ) V = ( v0 v0 1 ) ( v0 v1 v2 ) ( v1 v1 v1 1 ) ( 1 v1 v2 ) ( v2 v2 v2 v2 1 ) ( 1 v2 ) ( 1 )In addition, the shape of T is determined by these same flags as in the below table. ‘U’ denotes upper triangular ‘L’ denotes lower triangular ‘X’ denotes no current implementation We also provide the logical variable that represents the case in the code if it is implemented
|-----------------------------------------------------------| | | DIRECT = 'F' | DIRECT = 'B' | DIRECT = 'T' | |--------------+--------------+--------------+--------------| | STOREV = 'C' | U (QR) | L (QL) | X | | STOREV = 'R' | U (LQ) | L (RQ) | U (RQT) | | STOREV = 'T' | L (LQT) | X | X | |-----------------------------------------------------------|
Finally, the relationship between the (conjugate) transposed T matrices are as follows: (Note that T_{FC} denotes the T associated with calling this routine with DIRECT = ‘F’ and STOREV = ‘C’)
T_{TR} = (T_{BR})**H T_{FT} = (T_{FR})**H
Parameters
indirectSpecifies the order in which the elementary reflectors are multiplied to form the block reflector:
'F': H = H(0) H(1) … H(k-1) (Forward)'B': H = H(k-1) … H(1) H(0) (Backward)'T'(withstorev='R'): H = H(k-1) … H(1) H(0) (backward) but we return the T matrix that is already (conjugate) transposed
instorevSpecifies how the vectors which define the elementary reflectors are stored (see also Further Details):
'C': column-wise'R': row-wise'T': (Withdirect='F') Row-wise, but we return the T matrix that is already (conjugate) transposed.
innThe order of the block reflector H.
n>=0.inkThe order of the triangular factor T (= the number of elementary reflectors).
k>=1.inVArray of dimension (
ldv,k) ifstorev='C', (ldv,n) ifstorev='R'. The matrix V. See further details.inldvThe leading dimension of the array
V. Ifstorev='C',ldv>=max(1,n); ifstorev='R',ldv>=k.intauArray of dimension (
k).tau[i]must contain the scalar factor of the elementary reflector H(i).outTArray of dimension (
ldt,k). The k by k triangular factor T of the block reflector. Ifdirect='F', T is upper triangular; ifdirect='B', T is lower triangular. The rest of the array is not used.inldtThe leading dimension of the array
T.ldt>=k.
void clarft_lvl2(
const char* direct,
const char* storev,
const INT n,
const INT k,
const c64* restrict V,
const INT ldv,
const c64* restrict tau,
c64* restrict T,
const INT ldt
);
Functions
-
void zlarft_lvl2(const char *direct, const char *storev, const INT n, const INT k, const c128 *restrict V, const INT ldv, const c128 *restrict tau, c128 *restrict T, const INT ldt)#
ZLARFT_LVL2 forms the triangular factor T of a complex block reflector H of order n, which is defined as a product of k elementary reflectors.
If
direct='F', H = H(0) H(1) … H(k-1) and T is upper triangular;If
direct='B', H = H(k-1) … H(1) H(0) and T is lower triangular.If
storev='C', the vector which defines the elementary reflector H(i) is stored in columniof the arrayV, andH = I - V * T * V**H
If
storev='R', the vector which defines the elementary reflector H(i) is stored in rowiof the arrayV, andH = I - V**H * T * V
If
directorstorev='T', see Further Details for the shape of T- Further Details:
The shape of the matrix V and the storage of the vectors which define the H(i) is best illustrated by the following example with n = 5 and k = 3. The elements equal to 1 are not stored.
DIRECT = 'F' and STOREV = 'C': DIRECT = 'F' and STOREV = 'R': V = ( 1 ) V = ( 1 v0 v0 v0 v0 ) ( v0 1 ) ( 1 v1 v1 v1 ) ( v0 v1 1 ) ( 1 v2 v2 ) ( v0 v1 v2 ) ( v0 v1 v2 ) DIRECT = 'B' and STOREV = 'C': DIRECT = 'B' and STOREV = 'R': V = ( v0 v1 v2 ) V = ( v0 v0 1 ) ( v0 v1 v2 ) ( v1 v1 v1 1 ) ( 1 v1 v2 ) ( v2 v2 v2 v2 1 ) ( 1 v2 ) ( 1 )In addition, the shape of T is determined by these same flags as in the below table. ‘U’ denotes upper triangular ‘L’ denotes lower triangular ‘X’ denotes no current implementation We also provide the logical variable that represents the case in the code if it is implemented
|-----------------------------------------------------------| | | DIRECT = 'F' | DIRECT = 'B' | DIRECT = 'T' | |--------------+--------------+--------------+--------------| | STOREV = 'C' | U (QR) | L (QL) | X | | STOREV = 'R' | U (LQ) | L (RQ) | U (RQT) | | STOREV = 'T' | L (LQT) | X | X | |-----------------------------------------------------------|
Finally, the relationship between the (conjugate) transposed T matrices are as follows: (Note that T_{FC} denotes the T associated with calling this routine with DIRECT = ‘F’ and STOREV = ‘C’)
T_{TR} = (T_{BR})**H T_{FT} = (T_{FR})**H
Parameters
indirectSpecifies the order in which the elementary reflectors are multiplied to form the block reflector:
'F': H = H(0) H(1) … H(k-1) (Forward)'B': H = H(k-1) … H(1) H(0) (Backward)'T'(withstorev='R'): H = H(k-1) … H(1) H(0) (backward) but we return the T matrix that is already (conjugate) transposed
instorevSpecifies how the vectors which define the elementary reflectors are stored (see also Further Details):
'C': column-wise'R': row-wise'T': (Withdirect='F') Row-wise, but we return the T matrix that is already (conjugate) transposed.
innThe order of the block reflector H.
n>=0.inkThe order of the triangular factor T (= the number of elementary reflectors).
k>=1.inVArray of dimension (
ldv,k) ifstorev='C', (ldv,n) ifstorev='R'. The matrix V. See further details.inldvThe leading dimension of the array
V. Ifstorev='C',ldv>=max(1,n); ifstorev='R',ldv>=k.intauArray of dimension (
k).tau[i]must contain the scalar factor of the elementary reflector H(i).outTArray of dimension (
ldt,k). The k by k triangular factor T of the block reflector. Ifdirect='F', T is upper triangular; ifdirect='B', T is lower triangular. The rest of the array is not used.inldtThe leading dimension of the array
T.ldt>=k.
void zlarft_lvl2(
const char* direct,
const char* storev,
const INT n,
const INT k,
const c128* restrict V,
const INT ldv,
const c128* restrict tau,
c128* restrict T,
const INT ldt
);