syrk#

Performs a symmetric rank-k update.

Description

The syrk routines perform a rank-k update of a symmetric matrix C by a general matrix A. The operation is defined as:

\[C \leftarrow alpha*op(A)*op(A)^T + beta*C\]

where:

op(X) is one of op(X) = X or op(X) = X^T ,

alpha and beta are scalars,

C is a symmetric matrix and Ais a general matrix.

Here op(A) is n-by-k, and C is n-by-n.

syrk supports the following precisions.

T

float

double

std::complex<float>

std::complex<double>

T
`float`
`double`
`std::complex<float>`
`std::complex<double>`

syrk (Buffer Version)#

Syntax

namespace oneapi::mkl::blas::column_major {
    void syrk(sycl::queue &queue,
              onemkl::uplo upper_lower,
              onemkl::transpose trans,
              std::int64_t n,
              std::int64_t k,
              T alpha,
              sycl::buffer<T,1> &a,
              std::int64_t lda,
              T beta,
              sycl::buffer<T,1> &c,
              std::int64_t ldc)
}

namespace oneapi::mkl::blas::row_major {
    void syrk(sycl::queue &queue,
              onemkl::uplo upper_lower,
              onemkl::transpose trans,
              std::int64_t n,
              std::int64_t k,
              T alpha,
              sycl::buffer<T,1> &a,
              std::int64_t lda,
              T beta,
              sycl::buffer<T,1> &c,
              std::int64_t ldc)
}

Input Parameters

queue

The queue where the routine should be executed.

upper_lower

Specifies whether A’s data is stored in its upper or lower triangle. See oneMKL defined datatypes for more details.

trans

Specifies op(A), the transposition operation applied to A (See oneMKL defined datatypes for more details). Conjugation is never performed, even if trans = transpose::conjtrans.

n

Number of rows and columns in C. The value of n must be at least zero.

k

Number of columns in op(A).The value of k must be at least zero.

alpha

Scaling factor for the rank-k update.

a

Buffer holding input matrix A.

	`trans` = `transpose::nontrans`	`trans` = `transpose::trans` or `transpose::conjtrans`
Column major	`A` is an `n`-by-`k` matrix so the array `a` must have size at least `lda`*`k`.	`A` is an `k`-by-`n` matrix so the array `a` must have size at least `lda`*`n`
Row major	`A` is an `n`-by-`k` matrix so the array `a` must have size at least `lda`*`n`.	`A` is an `k`-by-`n` matrix so the array `a` must have size at least `lda`*`k`.

See Matrix Storage for more details.

lda

The leading dimension of A. It must be positive.

	`trans` = `transpose::nontrans`	`trans` = `transpose::trans` or `transpose::conjtrans`
Column major	`lda` must be at least `n`.	`lda` must be at least `k`.
Row major	`lda` must be at least `k`.	`lda` must be at least `n`.

beta

Scaling factor for matrix C.

c

Buffer holding input/output matrix C. Must have size at least ldc*n. See Matrix Storage for more details.

ldc

Leading dimension of C. Must be positive and at least n.

Output Parameters

c: Output buffer, overwritten by alpha*op(A)*op(A)^T + beta*C.

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

syrk (USM Version)#