![]() |
MAGMA 2.9.0
Matrix Algebra for GPU and Multicore Architectures
|
Functions | |
void | magmablas_clarfg (magma_int_t n, magmaFloatComplex_ptr dalpha, magmaFloatComplex_ptr dx, magma_int_t incx, magmaFloatComplex_ptr dtau, magma_queue_t queue) |
CLARFG generates a complex elementary reflector (Householder matrix) H of order n, such that. | |
void | magmablas_dlarfg (magma_int_t n, magmaDouble_ptr dalpha, magmaDouble_ptr dx, magma_int_t incx, magmaDouble_ptr dtau, magma_queue_t queue) |
DLARFG generates a real elementary reflector (Householder matrix) H of order n, such that. | |
void | magmablas_slarfg (magma_int_t n, magmaFloat_ptr dalpha, magmaFloat_ptr dx, magma_int_t incx, magmaFloat_ptr dtau, magma_queue_t queue) |
SLARFG generates a real elementary reflector (Householder matrix) H of order n, such that. | |
void | magmablas_zlarfg (magma_int_t n, magmaDoubleComplex_ptr dalpha, magmaDoubleComplex_ptr dx, magma_int_t incx, magmaDoubleComplex_ptr dtau, magma_queue_t queue) |
ZLARFG generates a complex elementary reflector (Householder matrix) H of order n, such that. | |
void magmablas_clarfg | ( | magma_int_t | n, |
magmaFloatComplex_ptr | dalpha, | ||
magmaFloatComplex_ptr | dx, | ||
magma_int_t | incx, | ||
magmaFloatComplex_ptr | dtau, | ||
magma_queue_t | queue ) |
CLARFG generates a complex elementary reflector (Householder matrix) H of order n, such that.
H * ( alpha ) = ( beta ), H**H * H = I. ( x ) ( 0 )
where alpha and beta are scalars, with beta real and |beta| = norm([alpha, x]), and x is an (n-1)-element complex vector. H is represented in the form
H = I - tau * ( 1 ) * ( 1 v**H ), ( v )
where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not Hermitian.
If the elements of x are all zero and dalpha is real, then tau = 0 and H is taken to be the unit matrix.
Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1.
[in] | n | INTEGER The order of the elementary reflector. |
[in,out] | dalpha | COMPLEX* on the GPU. On entry, pointer to the value alpha, i.e., the first entry of the vector. On exit, it is overwritten with the value beta. |
[in,out] | dx | COMPLEX array, dimension (1+(N-2)*abs(INCX)), on the GPU On entry, the (n-1)-element vector x. On exit, it is overwritten with the vector v. |
[in] | incx | INTEGER The increment between elements of X. INCX > 0. |
[out] | dtau | COMPLEX* on the GPU. Pointer to the value tau. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_dlarfg | ( | magma_int_t | n, |
magmaDouble_ptr | dalpha, | ||
magmaDouble_ptr | dx, | ||
magma_int_t | incx, | ||
magmaDouble_ptr | dtau, | ||
magma_queue_t | queue ) |
DLARFG generates a real elementary reflector (Householder matrix) H of order n, such that.
H * ( alpha ) = ( beta ), H**H * H = I. ( x ) ( 0 )
where alpha and beta are scalars, with beta real and |beta| = norm([alpha, x]), and x is an (n-1)-element real vector. H is represented in the form
H = I - tau * ( 1 ) * ( 1 v**H ), ( v )
where tau is a real scalar and v is a real (n-1)-element vector. Note that H is not symmetric.
If the elements of x are all zero and dalpha is real, then tau = 0 and H is taken to be the unit matrix.
Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1.
[in] | n | INTEGER The order of the elementary reflector. |
[in,out] | dalpha | DOUBLE PRECISION* on the GPU. On entry, pointer to the value alpha, i.e., the first entry of the vector. On exit, it is overwritten with the value beta. |
[in,out] | dx | DOUBLE PRECISION array, dimension (1+(N-2)*abs(INCX)), on the GPU On entry, the (n-1)-element vector x. On exit, it is overwritten with the vector v. |
[in] | incx | INTEGER The increment between elements of X. INCX > 0. |
[out] | dtau | DOUBLE PRECISION* on the GPU. Pointer to the value tau. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slarfg | ( | magma_int_t | n, |
magmaFloat_ptr | dalpha, | ||
magmaFloat_ptr | dx, | ||
magma_int_t | incx, | ||
magmaFloat_ptr | dtau, | ||
magma_queue_t | queue ) |
SLARFG generates a real elementary reflector (Householder matrix) H of order n, such that.
H * ( alpha ) = ( beta ), H**H * H = I. ( x ) ( 0 )
where alpha and beta are scalars, with beta real and |beta| = norm([alpha, x]), and x is an (n-1)-element real vector. H is represented in the form
H = I - tau * ( 1 ) * ( 1 v**H ), ( v )
where tau is a real scalar and v is a real (n-1)-element vector. Note that H is not symmetric.
If the elements of x are all zero and dalpha is real, then tau = 0 and H is taken to be the unit matrix.
Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1.
[in] | n | INTEGER The order of the elementary reflector. |
[in,out] | dalpha | REAL* on the GPU. On entry, pointer to the value alpha, i.e., the first entry of the vector. On exit, it is overwritten with the value beta. |
[in,out] | dx | REAL array, dimension (1+(N-2)*abs(INCX)), on the GPU On entry, the (n-1)-element vector x. On exit, it is overwritten with the vector v. |
[in] | incx | INTEGER The increment between elements of X. INCX > 0. |
[out] | dtau | REAL* on the GPU. Pointer to the value tau. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_zlarfg | ( | magma_int_t | n, |
magmaDoubleComplex_ptr | dalpha, | ||
magmaDoubleComplex_ptr | dx, | ||
magma_int_t | incx, | ||
magmaDoubleComplex_ptr | dtau, | ||
magma_queue_t | queue ) |
ZLARFG generates a complex elementary reflector (Householder matrix) H of order n, such that.
H * ( alpha ) = ( beta ), H**H * H = I. ( x ) ( 0 )
where alpha and beta are scalars, with beta real and |beta| = norm([alpha, x]), and x is an (n-1)-element complex vector. H is represented in the form
H = I - tau * ( 1 ) * ( 1 v**H ), ( v )
where tau is a complex scalar and v is a complex (n-1)-element vector. Note that H is not Hermitian.
If the elements of x are all zero and dalpha is real, then tau = 0 and H is taken to be the unit matrix.
Otherwise 1 <= real(tau) <= 2 and abs(tau-1) <= 1.
[in] | n | INTEGER The order of the elementary reflector. |
[in,out] | dalpha | COMPLEX_16* on the GPU. On entry, pointer to the value alpha, i.e., the first entry of the vector. On exit, it is overwritten with the value beta. |
[in,out] | dx | COMPLEX_16 array, dimension (1+(N-2)*abs(INCX)), on the GPU On entry, the (n-1)-element vector x. On exit, it is overwritten with the vector v. |
[in] | incx | INTEGER The increment between elements of X. INCX > 0. |
[out] | dtau | COMPLEX_16* on the GPU. Pointer to the value tau. |
[in] | queue | magma_queue_t Queue to execute in. |