Loading...
Searching...
No Matches
larfg: Generate Householder reflector
Dense LA » MAGMA BLAS and Auxiliary » Householder reflectors

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

## Detailed Description

## Function Documentation

## magmablas_clarfg()

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.

## magmablas_dlarfg()

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.

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.

## magmablas_slarfg()

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.

## magmablas_zlarfg()

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.

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.