rot#

Performs rotation of points in the plane.

Description

Given two vectors x and y of n elements, the rot routines compute four scalar-vector products and update the input vectors with the sum of two of these scalar-vector products as follows:

\[\begin{split}\left[\begin{array}{c} x\\y \end{array}\right] \leftarrow \left[\begin{array}{c} \phantom{-}c*x + s*y\\ -s*x + c*y \end{array}\right]\end{split}\]

If s is a complex type, the operation is defined as:

\[\begin{split}\left[\begin{array}{c} x\\y \end{array}\right] \leftarrow \left[\begin{array}{c} \phantom{-}c*x + s*y\\ -conj(s)*x + c*y \end{array}\right]\end{split}\]

rot supports the following precisions.

T	Tc	Ts
`sycl::half`	`sycl::half`	`sycl::half`
`oneapi::mkl::bfloat16`	`oneapi::mkl::bfloat16`	`oneapi::mkl::bfloat16`
`float`	`float`	`float`
`double`	`double`	`double`
`std::complex<float>`	`float`	`std::complex<float>`
`std::complex<double>`	`double`	`std::complex<double>`
`std::complex<float>`	`float`	`float`
`std::complex<double>`	`double`	`double`

rot (Buffer Version)#

Syntax

namespace oneapi::mkl::blas::column_major {
    void rot(sycl::queue &queue,
             std::int64_t n,
             sycl::buffer<T,1> &x,
             std::int64_t incx,
             sycl::buffer<T,1> &y,
             std::int64_t incy,
             Tc c,
             Ts s)
}

namespace oneapi::mkl::blas::row_major {
    void rot(sycl::queue &queue,
             std::int64_t n,
             sycl::buffer<T,1> &x,
             std::int64_t incx,
             sycl::buffer<T,1> &y,
             std::int64_t incy,
             Tc c,
             Ts s)
}

Input Parameters

queue: The queue where the routine should be executed.
n: Number of elements in vector x.
x: Buffer holding input vector x. The buffer must be of size at least (1 + (n - 1)*abs(incx)). See Matrix Storage for more details.
incx: Stride of vector x.
y: Buffer holding input vector y. The buffer must be of size at least (1 + (n - 1)*abs(incy)). See Matrix Storage for more details.
incy: Stride of vector y.
c: Scaling factor.
s: Scaling factor.

Output Parameters

x: Buffer holding updated buffer x.
y: Buffer holding updated buffer y.

Throws

This routine shall throw the following exceptions if the associated condition is detected. An implementation may throw additional implementation-specific exception(s) in case of error conditions not covered here.

oneapi::mkl::invalid_argument

oneapi::mkl::unsupported_device

oneapi::mkl::host_bad_alloc

oneapi::mkl::device_bad_alloc

oneapi::mkl::unimplemented

rot (USM Version)#

Syntax

namespace oneapi::mkl::blas::column_major {
    sycl::event rot(sycl::queue &queue,
                    std::int64_t n,
                    T *x,
                    std::int64_t incx,
                    T *y,
                    std::int64_t incy,
                    Tc c,
                    Ts s,
                    const std::vector<sycl::event> &dependencies = {})
}

namespace oneapi::mkl::blas::row_major {
    sycl::event rot(sycl::queue &queue,
                    std::int64_t n,
                    T *x,
                    std::int64_t incx,
                    T *y,
                    std::int64_t incy,
                    Tc c,
                    Ts s,
                    const std::vector<sycl::event> &dependencies = {})
}

Input Parameters

queue: The queue where the routine should be executed.
n: Number of elements in vector x.
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 Storage for more details.
incx: Stride of vector x.
y: Pointer to input vector y. The array holding input vector y must be of size at least (1 + (n - 1)*abs(incy)). See Matrix Storage for more details.
incy: Stride of vector y.
c: Scaling factor.
s: Scaling factor.
dependencies: List of events to wait for before starting computation, if any. If omitted, defaults to no dependencies.