MAGMA  2.3.0 Matrix Algebra for GPU and Multicore Architectures
larfg: Generate Householder reflector

## 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...

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...

ZLARFG generates a complex elementary reflector (Householder matrix) H of order n, such that. More...

## Function Documentation

 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.

Parameters
 [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.

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.

Parameters
 [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.

Parameters
 [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.

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.

Parameters
 [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.