MAGMA
2.3.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. More...  
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. More...  
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. More...  
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. More...  
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 (n1)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 (n1)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(tau1) <= 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+(N2)*abs(INCX)), on the GPU On entry, the (n1)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 (n1)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 (n1)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(tau1) <= 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+(N2)*abs(INCX)), on the GPU On entry, the (n1)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 (n1)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 (n1)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(tau1) <= 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+(N2)*abs(INCX)), on the GPU On entry, the (n1)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 (n1)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 (n1)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(tau1) <= 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+(N2)*abs(INCX)), on the GPU On entry, the (n1)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. 