# hpmv (USM Version)¶

Computes a matrix-vector product using a Hermitian packed matrix.

Syntax

event `hpmv`(queue &exec_queue, uplo upper_lower, std::int64_t n, T alpha, const T *a, const T *x, std::int64_t incx, T beta, T *y, std::int64_t incy, const vector_class<event> &dependencies = {})

The USM version of `hpmv` supports the following precisions and devices.

T

Devices Supported

`std::complex<float>`

Host, CPU, and GPU

`std::complex<double>`

Host, CPU, and GPU

Description

The hpmv routines compute a scalar-matrix-vector product and add the result to a scalar-vector product, with a Hermitian packed matrix. The operation is defined as

```y <- alpha*A*x + beta*y
```

where:

`alpha` and `beta` are scalars,

`A` is an `n`-by-`n` Hermitian matrix supplied in packed form,

`x` and `y` are vectors of length `n`.

Input Parameters

exec_queue

The queue where the routine should be executed.

upper_lower

Specifies whether A is upper or lower triangular. See Data Types for more details.

n

Number of rows and columns of `A`. Must be at least zero.

alpha

Scaling factor for the matrix-vector product.

a

Pointer to input matrix `A`. The array holding input matrix `A` must have size at least (`n`*(`n`+1))/2. See Matrix and Vector Storage for more details.

The imaginary parts of the diagonal elements need not be set and are assumed to be zero.

x

Pointer to input vector `x`. The array holding input vector `x` must be of size at least (1 + (`n` - 1)*abs(`incx`)). See Matrix and Vector Storage for more details.

incx

Stride of vector `x`.

beta

Scaling factor for vector `y`.

y

Pointer to input/output vector `y`. The array holding input/output vector `y` must be of size at least (1 + (`n` - 1)*abs(`incy`)). See Matrix and Vector Storage for more details.

incy

Stride of vector `y`.

dependencies

List of events to wait for before starting computation, if any. If omitted, defaults to no dependencies.

Output Parameters

y

Pointer to the updated vector `y`.

Return Values

Output event to wait on to ensure computation is complete.